// license that can be found in the LICENSE file.

// Verify that append arguments requirements are enforced by the
// compiler.

package main

func main() {

	s := make([]int, 8)

	_ = append()           // ERROR "missing arguments to append|not enough arguments for append"
	_ = append(s...)       // ERROR "cannot use ... on first argument|not enough arguments in call to append"

    }
  }
  std::vector<string> arguments;
  arguments.reserve(args_without_default_val.size() +
                    args_with_default_val.size());
  arguments.insert(arguments.end(),
                   std::make_move_iterator(args_without_default_val.begin()),
                   std::make_move_iterator(args_without_default_val.end()));
  arguments.insert(arguments.end(),
                   std::make_move_iterator(args_with_default_val.begin()),

        GUtil.addToCollection(arguments, true, args);
        return this;
    }

    public ProcessArgumentsSpec setArgs(List<String> arguments) {
        this.arguments.clear();
        args(arguments);
        return this;
    }

    public ProcessArgumentsSpec setArgs(Iterable<?> arguments) {
        this.arguments.clear();
        args(arguments);
        return this;
    }

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

     *
     * @param pos the position of the argument
     * @return the unwrapped value of the argument
     */
    Object getArgument(int pos);

    /**
     * Returns an <b>unwrapped</b> argument at the position {@code pos} or {@code null} if the {@code pos} is greater or equal than {@link #getArgsCount()}.

type T7 *T4
type T8 struct { F *T7 }

func main() {
	m := make(map[int]int)
	delete()        // ERROR "missing arguments|not enough arguments"
	delete(m)       // ERROR "missing second \(key\) argument|not enough arguments"
	delete(m, 2, 3) // ERROR "too many arguments"
	delete(1, m)    // ERROR "first argument to delete must be map|argument 1 must be a map|is not a map"

are elided from the presentation unless the -cmd flag is provided.

When run with one argument, the argument is treated as a Go-syntax-like
representation of the item to be documented. What the argument selects depends
on what is installed in GOROOT and GOPATH, as well as the form of the argument,
which is schematically one of these:

	go doc <pkg>
	go doc <sym>[.<methodOrField>]

            printer: PrettyPrinter,
        ) {
            if (annotation.arguments.isEmpty()) return
            printer.printCollection(annotation.arguments, prefix = "(", postfix = ")") { argument ->
                append(argument.name.render())
                append(" = ")
                append(KaAnnotationValueRenderer.render(argument.expression))
            }
        }
    }
}

package main

func main() {
	_ = copy(nil, []int{}) // ERROR "use of untyped nil|left argument must be a slice|expects slice arguments"
	_ = copy([]int{}, nil) // ERROR "use of untyped nil|second argument must be slice or string|expects slice arguments"
	_ = 1 + true           // ERROR "mismatched types untyped int and untyped bool|incompatible types|cannot convert"

}

// TODO(b/260267885): We may add a device argument when we want to support
// GPU MIG.
def TransferToDeviceOp: Gpu_Op<"transfer_to_device"> {
  let summary = "Transfer a CPU tensor to device.";

  let description = [{
    Transfer a CPU tensor to device.

    Example:
      %device_tensor = gpurt.transfer_to_device %cpu_tensor
  }];

  let arguments = (ins TFTensorType);
  let results = (outs TFTensorType);