[Compiler Bug]: Compiler optimizes away useMemo with manual dependencies

[KurtGokhan]

What kind of issue is this?

• React Compiler core (the JS output is incorrect, or your app works incorrectly after optimization)
• babel-plugin-react-compiler (build issue installing or using the Babel plugin)
• eslint-plugin-react-compiler (build issue installing or using the eslint plugin)
• react-compiler-healthcheck (build issue installing or using the healthcheck script)

Link to repro

https://playground.react.dev/#N4Igzg9grgTgxgUxALhASwLYAcIwC4AEwBUYCAsghhAQL4EBmMEGBA5DAgIZx5sDcAHQB2IgPRiCAQQAmMgmQA2DAGLCAFADcuiqAgCUBNMLBoZCAngAWF0hSo08NMhesWEADywJeCeQCMEKy5NNFwROAgTQiVVYQIAXgIPRIA+ZKFRYU8cfEYoYV4w+LsASXNhPDQ8AE8tHT0AGiMKqtq1Q2ARAgJI6JaESuqaxIGh9o1tXQNMns48WBKySmp1dUME9Prp-WaAbTNBtpqAXX1M2hEQWiA

Repro steps

We have a hook like this that basically returns the previous value if the calculated identity of the value hasn't changed (e.g. Dayjs object and its unix timestamp)

function useIdentity(value, identityFn) {
  const identity = identityFn(value);
  return useMemo(() => value, [identity]);
}

I noticed the tests for this were failing after enabling React Compiler.

This hook violates the rules-of-react and has the linter directives to disable it. But for some reason the compiler isn't able to detect the violation.

If I write the hook like this, the optimization is skipped as expected.

const selfFn = x => x;
function useIdentity(value, identityFn) {
  const identity = identityFn(value);
  return useMemo(() => selfFn(value), [identity]);
}

So I guess the hook doesn't respect the manual optimization because the () => value expression is too simple and thinks it can be optimized without issues.

How often does this bug happen?

Every time

What version of React are you using?

19.1.0

What version of React Compiler are you using?

19.1.0-rc.2

[josephsavona]

Thanks for posting! This is an interesting case.

So I guess the hook doesn't respect the manual optimization because the () => value expression is too simple and thinks it can be optimized without issues.

I haven't debugged to confirm, but I'm confident that's what's happening. We identify values that may be newly allocating vs references to values that should have been memoized elsewhere (props and hook return values are in the latter category). So when we check whether existing memoization was preserved for this example, we see that it was since the value is already memoized. But we should be inferring that the value has no dependencies, which differs from the manual dependencies, and skip the code on that account.