Per the spec, it’s illegal for a constant expression to truncate a floating point number: https://golang.org/ref/spec#Constant_expressions

The values of typed constants must always be accurately representable by values of the constant type. The following constant expressions are illegal:

[...]
int(3.14)    // 3.14 cannot be represented as an int

What part of the blog post led you to think it would work? That might clear up some confusion.

FWIW: It does work if you do it like this:

package main

import (
	"fmt"
	"time"
)

const Duration = int64(float64(time.Hour) * 2.5)

func main() {
	fmt.Printf("%v", Duration)
}

https://play.golang.org/p/E9tMZox7lv0

I can get behind this proposal.

time.Second is a typed constant with the (evaluated) value time.Duration(1000000000)

In constant arithmetic, 2.5 * 1000000000 correctly evaluated to 2500000000, an untyped integer that does not need to be truncated.

I believe this proposal is saying that untyped float constants multiplied by typed integer constants should be evaluated as typed integer constants, provided that no truncation occurs (such as the case of 2.5 * time.Second or 2.5 * time.Hour)

EDIT - It looks as if the proposal is stating that the current behavior (not compiling) is a bug. It is definitely not. However it could be useful to add this in as a feature for constants.