Repository: PaperMC/Paper
File: paper-api/src/main/java/org/bukkit/World.java (Java)

Code before:
     * chunk loads in queue.
     * <p>
     * The future will always be executed synchronously
     * on the main Server Thread.
     * @param block Block to load the corresponding chunk from
     * @param gen Should the chunk generate if it doesn't exist
     * @return Future that will resolve when the chunk is loaded
     */
    default @NotNull java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsyncUrgently(final @NotNull Block block, final boolean gen) {
        return this.getChunkAtAsync(block.getX() >> 4, block.getZ() >> 4, gen, true);
    }

    /**
     * Requests a {@link Chunk} to be loaded at the given coordinates
     * <p>
     * This method makes no guarantee on how fast the chunk will load,
     * and will complete the future at a later time.
     * <p>
     * You should use this method if you need a chunk but do not need it
     * immediately, and you wish for it to be prioritised over other
     * chunk loads in queue.
     * <p>
     * The future will always be executed synchronously
     * on the main Server Thread.
     *
     * @param x Chunk X-coordinate of the chunk - floor(world coordinate / 16)
     * @param z Chunk Z-coordinate of the chunk - floor(world coordinate / 16)
     * @return Future that will resolve when the chunk is loaded
     */
    default @NotNull java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsyncUrgently(final int x, final int z) {
        return this.getChunkAtAsync(x, z, true, true);
    }

    /**
     * Requests a {@link Chunk} to be loaded at the given coordinates.
     * <p>
     * This method makes no guarantee on how fast the chunk will load,
     * and will return the chunk to the callback at a later time.
     * <p>
     * You should use this method if you need a chunk but do not need it
     * immediately, and you wish to let the server control the speed
     * of chunk loads, keeping performance in mind.
     * <p>
     * The future will always be executed synchronously
     * on the main Server Thread.
     *
     * @param x Chunk X-coordinate of the chunk - floor(world coordinate / 16)
     * @param z Chunk Z-coordinate of the chunk - floor(world coordinate / 16)
     * @param gen Should the chunk generate if it doesn't exist
     * @param urgent If true, the chunk may be prioritised to be loaded above other chunks in queue
     *

Review comment (suggestion):
just chunk x coordinate should be enough.
chunk x and loc x is already confusing enough, I don't think we can explain that in a single line nicely without making it even more confusing.

Code after:
     * chunk loads in queue.
     * <p>
     * The future will always be executed synchronously
     * on the main Server Thread.
     * @param block Block to load the corresponding chunk from
     * @param gen Should the chunk generate if it doesn't exist
     * @return Future that will resolve when the chunk is loaded
     */
    default @NotNull java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsyncUrgently(final @NotNull Block block, final boolean gen) {
        return this.getChunkAtAsync(block.getX() >> 4, block.getZ() >> 4, gen, true);
    }

    /**
     * Requests a {@link Chunk} to be loaded at the given coordinates
     * <p>
     * This method makes no guarantee on how fast the chunk will load,
     * and will complete the future at a later time.
     * <p>
     * You should use this method if you need a chunk but do not need it
     * immediately, and you wish for it to be prioritised over other
     * chunk loads in queue.
     * <p>
     * The future will always be executed synchronously
     * on the main Server Thread.
     *
     * @param x Chunk x-coordinate
     * @param z Chunk z-coordinate
     * @return Future that will resolve when the chunk is loaded
     */
    default @NotNull java.util.concurrent.CompletableFuture<Chunk> getChunkAtAsyncUrgently(final int x, final int z) {
        return this.getChunkAtAsync(x, z, true, true);
    }

    /**
     * Requests a {@link Chunk} to be loaded at the given coordinates.
     * <p>
     * This method makes no guarantee on how fast the chunk will load,
     * and will return the chunk to the callback at a later time.
     * <p>
     * You should use this method if you need a chunk but do not need it
     * immediately, and you wish to let the server control the speed
     * of chunk loads, keeping performance in mind.
     * <p>
     * The future will always be executed synchronously
     * on the main Server Thread.
     *
     * @param x Chunk x-coordinate
     * @param z Chunk z-coordinate
     * @param gen Should the chunk generate if it doesn't exist
     * @param urgent If true, the chunk may be prioritised to be loaded above other chunks in queue
     *