[BUG] anonymous functions and things inside decltype should never be forward declared

[farmerpiki]

Describe the bug
I think anonymous functions should never be forward declared, and IMHO decltype should not be implied for them when using inside a type alias (and possibly other scenarios as well)

currently there's no usable equivalent to the cpp1 syntax for this that works
using pq_conn_ptr = std::unique_ptr<PGconn, decltype([](PGconn *ptr) { PQfinish(ptr); })>;

To Reproduce
Steps to reproduce the behavior:

1. Sample code - distilled down to minimal essentials please
   I tried this instead
   pq_conn_ptr : type == std::unique_ptr<PGconn, decltype(: (ptr : *PGconn) = { PQfinish(ptr); })>;
   and using it just as
   p: pq_conn_ptr = ();
2. Command lines including which C++ compiler you are using
   cppfront and g++-13 but I guess the issue would be with any compiler cause it's caused by the generated code
3. Expected result - what you expected to happen
   I expected it to generate the above using declaration
4. Actual result/error
   using pq_conn_ptr = std::unique_ptr<PGconn,decltype([](PGconn* ptr) -> void;)>;
   the error is that the body of the lambda is missing

[JohelEGP]

Seems like a duplicate of #385.

[JohelEGP]

But I think it actually isn't.
This is a case where it can be valid.
A type alias can't be forward declared,
so the function expression can be emitted in full without problems.

[farmerpiki]

I'm not trying to ban the use of this (as the referenced bug suggests), as this is valid syntax (at least the cpp1 version) and I think should be representable in the new syntax.
Do you guys think I should make a new suggestion to automatically use decltype for lambdas inside type alias definitions like this, I think it's the only valid way to use a lambda in a type if you also use decltype on it?

[JohelEGP]

Do you guys think I should make a new suggestion to automatically use decltype for lambdas inside type alias definitions like this, I think it's the only valid way to use a lambda in a type if you also use decltype on it?

You can definitely use it to initialize a NTTP: https://cpp2.godbolt.org/z/ja8x6E76j.

[farmerpiki]

I was suggesting it just for types.
I'm not sure your example proves much as in this one https://cpp2.godbolt.org/z/v48x1Wa5G it's a very clearly different function and it still works (as in code is generated for it and it compiles)
I'm pretty sure as a rule you can't forward declare lambdas at all cause they get a different implementation every time, that's why they added the ability to use decltype on them, like in my shared_ptr example. That way you get both the type and the implementation in one go. I'm not an expert in standardese so ... I may have understood stuff wrongly.

[JohelEGP]

Oh, so is your suggestion is to replace them with their type?
I misunderstood it as automatically inserting decltype() around it
because they're not valid NTTPs (you said "can't be used any other way").

Either way, I don't see how it can generally work.
The indirection through the decltype() changes nothing.

A function expression in a declaration's signature just doesn't mix with order independence.

[farmerpiki]

You are right, it doesn't mix with order independence.
All I want is a way to express this in a the new syntax, the other thing was a question and I got my answer, I was wrong in thinking there are no other uses.

before allowing the decltype I just could not declare a type for this (my initial example):
using pq_conn_ptr = std::unique_ptr<PGconn, decltype([](PGconn *ptr) { PQfinish(ptr); })>;

I had to always use auto as return type and use CTAD to initialize the unique_ptr everywhere, it gets ugly pretty quickly compared to being able to declare a type and have a single lambda everywhere, also the compiled code is shorter because the linker can't figure out that the lambdas are all the same without the newer decltype syntax.

[JohelEGP]

Well, here we have a valid use-case.
The bug seems to be that a function expression is attempted to be forward-declared.

[farmerpiki]

here's a cleaner example so people don't bother with libpq or modifying the example by hand
https://cpp2.godbolt.org/z/WrabY5Gvd

cleaned up code:

// using fptr = std::unique_ptr<FILE, decltype([](FILE *ptr) { fclose(ptr); })>;
fptr: type == std::unique_ptr<FILE, decltype(: (ptr: *FILE) = fclose(ptr))>;

main: () = {
    f: fptr = (fdopen(0, "r"));
}

can you point me where to look if I want to fix this? I might have some time over the weekend

[JohelEGP]

cppfront/source/cppfront.cpp

Lines 1288 to 1290 in 4376132

	//---------------------------------------------------------------------
	// Do phase1_type_defs_func_decls
	//

During phase 1,
when a function is being emitted,
if it's actually a function expression,
checks for phase 2 should be ignored.

[JohelEGP]

if it's actually a function expression,

That check is actually done in another use-case: https://cpp2.godbolt.org/z/zGerbTY33.
You should be able to find where the check is done by searching for the error message.