[BUG] in parameter's type is non-deducible #367

Activity

1. JohelEGP

   added

   bugSomething isn't workingSomething isn't working

   on Apr 13, 2023
2. JohelEGP commented on Apr 23, 2023

   

   JohelEGP

   on Apr 23, 2023

   ContributorAuthor

   More actions

   Minimal reproducer (https://godbolt.org/z/3v8b36s3q):

   f: <T: std::regular> (_: T) = { }
   main: () = f(0);
   

   Commands:

   cppfront x.cpp2
   clang++17 -std=c++2b -stdlib=libc++ -I $CPPFRONT_INCLUDE_DIR x.cpp

   Expected result:

   template<std::regular T> auto f(T _) -> void{}

   Actual result and error:

   template<std::regular T> auto f(cpp2::in<T> _) -> void{}

   Full generated Cpp1.

   //=== Cpp2 type declarations ====================================================
   
   
   #include "cpp2util.h"
   
   
   
   //=== Cpp2 type definitions and function declarations ===========================
   
   #line 1 "/app/main.cpp2"
   template<std::regular T> auto f(cpp2::in<T> _) -> void;
   auto main() -> int;
   
   
   //=== Cpp2 function definitions =================================================
   
   #line 1 "/app/main.cpp2"
   template<std::regular T> auto f(cpp2::in<T> _) -> void{}
   auto main() -> int { f(0);  }

   main.cpp2:2:22: error: no matching function for call to 'f'
   auto main() -> int { f(0);  }
                        ^
   main.cpp2:1:31: note: candidate template ignored: couldn't infer template argument 'T'
   template<std::regular T> auto f(cpp2::in<T> _) -> void{}
                                 ^
   1 error generated.
   
3. hsutter

   closed this as completedin b50ea2fon Apr 23, 2023
4. hsutter commented on Apr 23, 2023

   

   hsutter

   on Apr 23, 2023

   Owner

   More actions

   Thanks! There are two examples here, taking them one by one...

   f: <T> (_: std::vector<T>) = { }

   You're right, I should include that in the "hey this is using a template parameter name" deduced-type case.

   I've done that now in the above commit -- please check?

   f: <T: std::regular> (_: T) = { }

   This is using the value parameter syntax (see NOTE), so in this position Cpp2 expects std::regular is a type (not a concept). I realize that Cpp1 allows a concept name in the analogous position, but Cpp2 aims to have a syntax that does not require name lookup to decide what something is (either actual name lookup in the compiler, or even just visual name lookup for the programmer to figure it out), so my stake in the ground is that anything of this form should mean "value."

   Today you can express this using requires, like this

   f: <T> (_: T) requires std::regular<T> = { }
   

   which lowers to this

   template<typename T> auto f(T const& _) -> void
   requires (std::regular<T>)
   {}
   

   I've thought of supporting a syntactic sugar for this case along the lines of

   //  Speculative possibility (not implemented)
   f: <T is std::regular> (_: T) = { }
   

   and make it lower to the same thing. But for now the answer is requires... as a user who encountered and reported this, does that seem like a reasonable answer to you? (Be frank!)

   ---

   (NOTE) In general in parameters of templated type T are emitted as const T& for this reason, so this

   //  A type parameter says 'type' (possibly implicitly)
   f: <T: type> (_: T) = { }
   

   or its short form

   f: <T> (_: T) = { }    // same, omitting default optional syntax
   

   lowers to this

   template<typename T> auto f(T const& _) -> void{}
   

   Note that the syntax for non-type (value) parameters is the same as for objects, so this

   //  A value parameter does not say 'type'
   f: <I: int> (_: I) = { }
   

   lowers to this

   template<int I> auto f(cpp2::in<I> _) -> void{}
   
5. JohelEGP commented on Apr 23, 2023

   

   JohelEGP

   on Apr 23, 2023

   ContributorAuthor

   More actions

   I've done that now in the above commit -- please check?

   The generated code looks good now.

   as a user who encountered and reported this, does that seem like a reasonable answer to you? (Be frank!)

   Yes! I felt something was odd, but couldn't quite grasp it.
6. zaucy

   added a commit that references this issue on Dec 5, 2023

   Also detect dependent parameter types of the form `something<...,T,..…

   ...

   This issue will close once commit 5e1e58f is merged into the 'main' branch.

   5e1e58f
7. GregWagner

   added a commit that references this issue on Feb 4, 2024

   Also detect dependent parameter types of the form `something<...,T,..…

   ...

   This issue will close once commit b50ea2f is merged into the 'main' branch.

   b50ea2f