Why should I typecast a 32 bit address to 16 bit to store a 16 bit data

I am working on an STM32 Flash, I came across this function that writes 16-bit data to an address that is 32-bit. Why should I typecast this address like *(__IO uint16_t*)Address = Data; which expands to *(volatile uint16_t *)Address = Data;

static void FLASH_Program_HalfWord(uint32_t Address, uint16_t Data)
{
  /* Check the parameters */
  assert_param(IS_FLASH_ADDRESS(Address));
  
  /* If the previous operation is completed, proceed to program the new data */
  CLEAR_BIT(FLASH->CR, FLASH_CR_PSIZE);
  FLASH->CR |= FLASH_PSIZE_HALF_WORD;
  FLASH->CR |= FLASH_CR_PG;

  *(__IO uint16_t*)Address = Data;
}

I expect *((uint32_t *)Address) = data to be sufficient.

Pointer is a memory address. A memory address itself is 32-bit. It is the data it's pointing to that is different. When you have pointer to 32-bit integer, the compiler generates instructions that load and store 32 bits of data at a time. When you have a pointer to 16-bit integer, the compiler generates instructions that load and store 16 bits of data. Imagine example:

MemAdd: 0x100 0x101 0x102 0x103
MemVal: 0xFF  0xFF  0xFF  0xFF

Pointer: 0x100

if you *(uint32_t*)(Pointer) = 0x1234, the memory at 0x100-0x103 will contain 0x00001234. If you *(uint16_t*)(Pointer) = 0x1234, the memory at 0x100-0x103 will contain 0xFFFF1234. The other two bytes were never overwritten.

Since you want to write half-word to flash, you want to tell the compiler to generate instructions for storing 16-bit value.

This operation converts it to the pointer to uint16_t and then dereferences it. It is done to force use of 16 bits write/read instructions in the generated code.

void write16(uint32_t addr, uint16_t val)
{
    *(volatile uint16_t *)addr = val;
}

void write8(uint32_t addr, uint16_t val)
{
    *(volatile uint8_t *)addr = val;
}

void write32(uint32_t addr, uint16_t val)
{
    *(volatile uint32_t *)addr = val;
}

write16:
        strh    r1, [r0]        @ movhi
        bx      lr
write8:
        uxtb    r1, r1
        strb    r1, [r0]
        bx      lr
write32:
        str     r1, [r0]
        bx      lr

When programing flash it is very important as it is not "normal" write to the memory.