<< worked as expected:

https://go.dev/play/p/VL3fooh-F1z

package main

import "fmt"

func main() {
	const a = int(1) << 2.0
	fmt.Println(a)
	const b = 1 << 2.0
	fmt.Println(b)
}

For constant expressions, << is a little different from the other operators:

If the left operand of a constant shift expression is an untyped constant, the result is an integer constant;

So the result of const b = 1 << 2.0 is an integer constant, which means that 1 is considered an (promoted to?) integer. On the other hand:

If the untyped operands of a binary operation (other than a shift) are of different kinds, the result is of the operand's kind that appears later in this list: integer, rune, floating-point, complex.

So the result of const b = 1 % 2.0 is of kind floating point, which means that 1 is treated as a constant of floating-point kind, and then you get the error about % not being defined on floats.

Thank you for elaboration. I understand the current behavior is correct from the specification.

I was wondering why the shift operators are special, but this issue is not a bug anyway. Let me close this.

There was a lot of discussion and fiddling with the types of the shift operators in the early days of Go, and they are still complicated. The shift operators are the only operators that don't use the same type on both the left and right hand sides. Go requires a way to set the type of an untyped constant. What is right way to determine the type of an untyped constant shifted by a non-constant value? What the language finally decided was our best answer to that question.