```python
def set_left_most_unset_bit(n):
    """
    Sets the leftmost unset bit of a non-negative integer.

    Args:
        n: A non-negative integer.

    Returns:
        An integer with the leftmost unset bit of n set to 1.
    """
    if n < 0:
        # This function is typically defined for non-negative integers.
        # Handling negative numbers would require a decision on bit representation
        # (e.g., two's complement and word size), which is ambiguous here.
        # We can raise an error or handle as per specific requirements.
        raise ValueError("Input must be a non-negative integer")

    # For n=0, its bit length is 0. For n>0, it's the number of bits
    # needed to represent the integer. The MSB is at position num_bits - 1.
    num_bits = n.bit_length()

    # Iterate downwards from the most significant bit's position.
    # For n=10 (binary 1010), num_bits is 4. The loop checks positions 3, 2, 1, 0.
    # For n=0, num_bits is 0, so this loop does not run.
    for bit_position in range(num_bits - 1, -1, -1):
        # Check if the bit at the current position is 0 (unset).
        # (n >> bit_position) & 1 isolates the bit.
        is_bit_set = (n >> bit_position) & 1
        if not is_bit_set:
            # Found the leftmost unset bit. Set it using a bitwise OR
            # with a mask (1 shifted to the correct position) and return.
            mask = 1 << bit_position
            return n | mask

    # This part is reached if the loop completes without finding an unset bit.
    # This happens in two cases:
    # 1. n = 0 (the loop is empty). The leftmost unset bit is at position 0.
    # 2. n has all bits set in its representation (e.g., 7 is 111).
    #    The leftmost unset bit is just to the left of the current MSB.
    # In both cases, the position of the bit to set is num_bits.
    mask = 1 << num_bits
    return n | mask
```