Reference to parameter of one function, spliced into body of another without error

[rbock]

Hi,

While playing with the new splice syntax (beautiful, btw), I ran into this curiosity:

using info = decltype(reflexpr(void));

template<info V> 
constexpr auto get()
{
  return [<V>];
}

template<typename T>
constexpr auto copy_indirect(T&& t)
{
  // IFF we are trying to obtain a constexpr value from this function, this fails:
  return get<reflexpr(t)>();
  // "function parameter 't' with unknown value cannot be used in a constant expression"
}

template<typename T>
constexpr auto copy_semi_direct(T&& t)
{
  constexpr auto i = reflexpr(t); // No problem here
  return [<i>];
} 

template<typename T>
constexpr auto copy_direct(T&& t)
{
  return [<reflexpr(t)>]; // No problem here
}

int main(int argc, char**argv)
{
  auto a = copy_indirect(1); // Works
  auto b = copy_indirect(argc); // Works
  constexpr auto x = copy_indirect(1); // Fails
  constexpr auto y = copy_semi_direct(1); // Works
  constexpr auto z = copy_direct(1); // Works
}

[DarkArc]

template<info V> 
constexpr auto get()
{
  return [<V>];
}

template<typename T>
constexpr auto copy_indirect(T&& t)
{
  // IFF we are trying to obtain a constexpr value from this function, this fails:
  return get<reflexpr(t)>();
  // "function parameter 't' with unknown value cannot be used in a constant expression"
}

So when copy_indrect gets instantiated, it's going to try to instantiate get, when it does that, it's not working with a function call of copy_indirect just the parameter declaration T&& t. It has no way to predict what the future value of t is, so it can't take that as a constexpr value, or form a reference to t from within get function -- t isn't local to get.

---

It works in the other two cases, because you're establishing a reference to t.

template<typename T>
constexpr auto copy_semi_direct(T&& t)
{
  constexpr auto i = reflexpr(t); // No problem here
  return [<i>];
} 

template<typename T>
constexpr auto copy_direct(T&& t)
{
  return [<reflexpr(t)>]; // No problem here
}

These two are effectively the same, but spelled slightly differently, in the first the reflection is just stored in a constexpr variable, but the splice still means the same thing, splice in a reference to t. i.e. the generated body for both is:

(T&& t) {
  return t;
}

---

Hope that helps, and glad you're liking the new syntax, though [< >] may change to [: :] given some discussion with others -- ...hopefully you like that syntax as well :).

[rbock]

So when copy_indrect gets instantiated, it's going to try to instantiate get, when it does that, it's not working with a function call of copy_indirect just the parameter declaration T&& t. It has no way to predict what the future value of t is, so it can't take that as a constexpr value, or form a reference to t from within get function -- t isn't local to get.

Thanks for the super quick answer! However, I think I am missing something. I am still confused why

  auto b =           copy_indirect(argc); // Works
  constexpr auto x = copy_indirect(1); // Fails

Given your explanation, I would expect both calls to fail?

Hope that helps, and glad you're liking the new syntax, though [< >] may change to [: :] given some discussion with others -- ...hopefully you like that syntax as well :).

That's nice, too :-)

[DarkArc]

I actually missed something, responding a bit too quickly it seems -- my bad. That should not be working in the non-constexpr case. We're not enforcing something with local variables correctly, and that could be a big problem.

Thanks for pointing this out!