# V1080. Call of 'std::is_constant_evaluated' function always returns the same value.

The diagnostic rule warns that the 'std::is_constant_evaluated' function's return value has no ability to ever change. This may lead to unreachable code.

This rule covers two cases:

- The function is called in the context, that is always the compile-time context, and returns 'true'.
- The function is called in the context, that is always the runtime context, and returns 'false'.

Example: we need to write a function that would contain two versions of one algorithm - one version for compile-time, the other version for runtime. We'll use the 'std::is_constant_evaluated' function to differentiate between these two implementations.

    #include <type_traits>

    constexpr void foo()
    {
      constexpr auto context = std::is_constant_evaluated();
      //....
      if (context)
      {
        // compile-time logic
      }
      else
      {
        // runtime logic
      }
    }

Here the 'std::is_constant_evaluated' function always returns 'true'. The 'else' branch contains unreachable code.

The opposite situation may happen if we remove the 'costexpr' specifier from the 'context' variable and from the 'foo' function.

    #include <type_traits>

    void foo()
    {
      auto context = std::is_constant_evaluated();
      //....
      if (context)
      {
        // compile-time logic
      }
      else
      {
        // runtime logic
      }
    }

Here the 'context' variable is always 'false'. The code becomes unreachable as early as the 'then' branch.

The 'std::is_constant_evaluated' always returns 'true' if called in one of the following locations:

- inside 'static_assert';
- inside the 'consteval' function;
- inside the 'if constexpr' condition.

The 'std::is_constant_evaluated' always returns 'true' if called here:

- inside a function that is not marked with the 'constexpr' / 'consteval' specifiers.

This diagnostic is classified as:

CWE-570 CWE-571