Inspection for variables assigned but not read before the next assignment

[dlsniper]

package main

func main() {
    demo := "first"
    demo = "second" // demo is assigned and not used before this assignment

    demo2 := "hello"
    demo2, demo3 := "third", 1 // demo2 is assigned and not used before this assignment

    _, _, _ = demo, demo2, demo3
}

[sjamesr]

What's the motivation for this inspection? Seems like there are legitimate situations where you want to assign before reading, e.g.

x := "something"
if y {
  x = "something else"
}
...

[dlsniper]

@sjamesr right, that's case where the assignment is valid but inefficient. By that I mean it could be done in an else branch.

The target I have in mind are assignments like this:

package main

import (
    "fmt"
)

func doSomething() bool {
    return false
}

func bar() error {
    return fmt.Errorf("%s", "demo")
}

func demo() (err error) {
    if !doSomething() {
        err = fmt.Errorf("%s", "dem") // unhandled assignment
    }

    return bar()
}

func main() {
    _ = demo()

    err := bar() // unhandled assignment
    err = bar()
    _ = err
}

Maybe we can limit it only to error types by default and then have an option (turned off by default) to run regardless of type?
I would do the error type as warning and other types as weak warnings.

Would that make more sense?