Adrian Kuegel <******@****.***> 1648469008 -0700

	Printf("%[3]*s x", "hi", 2)            // ERROR "Printf format has invalid argument index \[3\]"
	_ = fmt.Sprintf("%[3]d x", 2)          // ERROR "Sprintf format has invalid argument index \[3\]"
	Printf("%[2]*.[1]*[3]d x", 2, "hi", 4) // ERROR "Printf format %\[2]\*\.\[1\]\*\[3\]d uses non-int \x22hi\x22 as argument of \*"

    public List<String> getArguments() {
        return arguments;
    }

    @Override
    public DefaultGradleRunner withArguments(List<String> arguments) {
        this.arguments = Collections.unmodifiableList(new ArrayList<>(arguments));
        return this;
    }

    @Override
    public DefaultGradleRunner withArguments(String... arguments) {
        return withArguments(Arrays.asList(arguments));
    }

        kFunction: KFunction<*>,
        receiver: Any,
        arguments: Map<DataParameter, Any?>,
        hasLambda: Boolean,
        configureLambdaHandler: ConfigureLambdaHandler
    ): Binding? {
        var captor: ConfigureLambdaHandler.ValueCaptor? = null
        val map = buildMap(arguments.size + 1) {
            val namedArguments = arguments.mapKeys { (param, _) -> param.name }
            var used = 0

    return kmProperty
}


internal
fun genericTypeOf(type: KmType, argument: KmType): KmType {
    type.arguments += KmTypeProjection(KmVariance.INVARIANT, argument)
    return type
}


internal
fun genericTypeOf(type: KmType, arguments: Iterable<KmType>): KmType {
    arguments.forEach { genericTypeOf(type, it) }
    return type
}


internal

// does the following:
//
//   - converts its arguments to a slice of Values.
//   - runs results := fn(args).
//   - returns the results as a slice of Values, one per formal result.
//
// The implementation fn can assume that the argument [Value] slice
// has the number and type of arguments given by typ.
// If typ describes a variadic function, the final Value is itself

    private static final String NIX_LONG_COMMAND_EXCEPTION_MESSAGE = "error=7, Argument list too long";

    public static boolean hasCommandLineExceedMaxLength(String command, List<String> arguments) {
        int commandLineLength = command.length() + arguments.stream().map(String::length).reduce(Integer::sum).orElse(0) + arguments.size();
        return commandLineLength > getMaxCommandLineLength();
    }

		x.mode = invalid
		return
	}

	// The conversion argument types are final. For untyped values the
	// conversion provides the type, per the spec: "A constant may be
	// given a type explicitly by a constant declaration or conversion,...".
	if isUntyped(x.typ) {
		final := T
		// - For conversions to interfaces, except for untyped nil arguments
		//   and isTypes2, use the argument's default type.

class KaAnnotationImpl(
    classId: ClassId?,
    psi: KtCallElement?,
    useSiteTarget: AnnotationUseSiteTarget?,
    hasArguments: Boolean,

    /**
     * A list of annotation arguments which were applied when constructing annotation. Every argument is [KaAnnotationValue]
     */
    lazyArguments: Lazy<List<KaNamedAnnotationValue>>,
    index: Int?,

    /**

	}

	// Test aliasing the two arguments.
	if out := f(v1, y, y); out != v1 || !equal(v1, v) {
		t.Logf("f(v, y1, y2) != f(v, y, y)")
		return false
	}
	// Test aliasing the two arguments and the receiver.
	v1.Set(y)
	if out := f(v1, v1, v1); out != v1 || !equal(v1, v) {
		t.Logf("f(v, y1, y2) != f(y, y, y)")
		return false
	}

	// Ensure the arguments were not modified.