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.

// that can be used with InferShapeForFunction.
// TF NodeShape uses `,` to separate dimensions, and `:` to separate arguments.
// Ex: 1,2:3,4,5:6,? --> [[1, 2], [3, 4, 5], [6, ?]]
absl::StatusOr<SmallVector<SmallVector<int64_t>>> ParseArgumentShapes(
    absl::string_view input_shapes);

// Given a list of refined shapes matching the function arguments of func, runs

    llvm::StringRef function_name, llvm::ArrayRef<Tensor> arguments) {
  // Get the kernel entrypoint function.
  const Function* compute = bef_file_->GetFunction(function_name);
  CHECK(compute) << "Entrypoint function not found";
  CHECK_EQ(arguments.size() + 1, compute->num_arguments())
      << "Wrong number of arguments for function " << function_name.str();

  // Prepare function arguments from ready Chain and input Tensors.

ECL0001={0} not found
ECL0008=argument[{0}] is null.
ECL0009=argument[{0}] is illegal. because {1}.
ECL0010=argument[{0}] is null or empty string.
ECL0011=argument[{0}] is null or empty array.
ECL0012=argument[{0}] is null or empty collection.
ECL0013=argument[{0}] is null or empty map.
ECL0014=argument[{0}] which is null the index of array is negative integer.
ECL0015=argument[{0}] which is null the index of array exceed the size of array[{1}].

    final ArgWriter argWriter = ArgWriter.unixStyle(printWriter)

    def "writes single argument to line"() {
        when:
        argWriter.args("-nologo")

        then:
        writer.toString() == toPlatformLineSeparators("-nologo\n")
    }

    def "writes multiple arguments to line"() {
        when:
        argWriter.args("-I", "some/dir")

        then: