cel.UnaryBinding(getQuery))},
	"isURL": {
		cel.Overload("is_url_string", []*cel.Type{cel.StringType}, cel.BoolType,
			cel.UnaryBinding(isURL))},
}

func (*urls) CompileOptions() []cel.EnvOption {
	options := []cel.EnvOption{}
	for name, overloads := range urlLibraryDecls {
		options = append(options, cel.Function(name, overloads...))
	}
	return options
}

     * This method is useful for handling optional arguments represented as "telescopic" overloads, like the one of the {@code Runtime.exec}:
     * <pre>
     *     Runtime.exec("/usr/bin/echo")
     *     Runtime.exec("/usr/bin/echo", new String[] {"FOO=BAR"})
     * </pre>
     *

var quantityLibraryDecls = map[string][]cel.FunctionOpt{
	"quantity": {
		cel.Overload("string_to_quantity", []*cel.Type{cel.StringType}, apiservercel.QuantityType, cel.UnaryBinding((stringToQuantity))),
	},
	"isQuantity": {
		cel.Overload("is_quantity_string", []*cel.Type{cel.StringType}, cel.BoolType, cel.UnaryBinding(isQuantity)),
	},
	"sign": {

	options := []cel.EnvOption{cel.Types(apiservercel.IPType),
		cel.Variable(apiservercel.IPType.TypeName(), types.NewTypeTypeWithParam(apiservercel.IPType)),
	}
	for name, overloads := range ipLibraryDecls {
		options = append(options, cel.Function(name, overloads...))
	}
	return options
}

func (*ip) ProgramOptions() []cel.ProgramOption {
	return []cel.ProgramOption{}
}

func stringToIP(arg ref.Val) ref.Val {

                // TODO better diagnostics reporting
                throw new IllegalStateException("vararg overloads are not supported yet");
            }
            current = current.childrenByMatchEntry.computeIfAbsent(matchEntry, key -> new SignatureTree());
        }
        if (current.leaf != null) {

                }
                if (previousDeclaringClass == declaringClass) {
                    throw new GradleException(String.format(
                        "Cannot use @TaskAction annotation on multiple overloads of method %s.%s()",
                        declaringClass.getSimpleName(), method.getName()
                    ));
                } else if (previousDeclaringClass != null) {
                    continue;

        fromString()      | "ProcessGroovyMethods.execute(command, (String[]) null, project.file(\"$pwd\"))"                  | pwd               | ""

        // Runtime.exec() overloads
        fromString()      | "Runtime.getRuntime().exec(command)"                                                              | ""                | ""

        fromString()      | "ProcessGroovyMethods.execute(command, null as Array<String>?, file(\"$pwd\"))"     | pwd               | ""

        // Runtime.exec() overloads
        fromString()      | "Runtime.getRuntime().exec(command)"                                                | ""                | ""

     * </p>
     *
     * @param listener The listener
     * @return this
     * @since 1.0-milestone-7
     */
    @SuppressWarnings("overloads")
    LongRunningOperation addProgressListener(ProgressListener listener);

    /**
     * Adds a progress listener which will receive progress events of all types as the operation runs.
     *

                    @Inject
                    public TaskB() { }
                }

                public class LambdaPlugin implements Plugin<Project> {
                    // Use these overloads as lambda implementation methods - they should appear in SerializedLambda
                    static void foo(TaskA taskA) { }
                    static void foo(TaskB taskB) { }

                    @Override