staticcheck: detect unused values inside closures

[ainar-g]

Found this while refactoring something. Consider this code:

func returnErr() error { return nil }

func main() {
	err := returnErr()
	if err != nil {
		panic(err)
	}

	err = errors.New("ignored")
}

Staticcheck will correctly warn that the second value of err is never used:

scbug.go:15:2: this value of err is never used (SA4006)

But if we use closures, staticcheck fails to detect the bug:

func f(g func()) { g() }

func returnErr() error { return nil }

func main() {
	err := returnErr()
	if err != nil {
		panic(err)
	}

	f(func() {
		err = errors.New("ignored")
	})
}

This code generates no warnings, despite the fact that err is unchecked.

[dominikh]

This is essentially because the check, as written, only works on local, non-escaping variables. It bails out as soon as a variable's address is taken. We cannot trivially determine if the variable is being read at some point or not once its address has been taken. We'll have to do whole program analysis and take pointer aliasing into consideration.

[ainar-g]

FWIW, LLVM's clang-tidy doesn't find the dead load in similar C++ code either:

void f(const std::function<void()> &g) { g(); }

int returnInt() { return 0; }

int main() {
  int i = returnInt();
  assert(i == 0);

  // i = 42;
  f([&i]() { i = 42; });

  return 0;
}

So I guess this is really a tough feature to get right.