Disable UFCS for multiple template args, closes #82

Alpha limitation: Macros don't like commas
Happy to entertain a better solution that makes it work, feel free to submit an issue or better yet a PR if you have a good solution that passes regression tests but also makes `x.f<a,b>()` successfully call a non-member `f`.

Author: hsutter

regression-tests/mixed-ufcs-multiple-template-arguments.cpp2

@@ -0,0 +1,23 @@
+
+template <auto from, auto to>
+auto substr(const std::string& input) -> std::string {
+    return input.substr(from, to-from);
+}
+
+struct X {
+    std::string input;
+    X(const std::string& input) : input{input} { }
+    template <auto from, auto to>
+    auto substr() -> std::string {
+        return input.substr(from, to-from);
+    }
+};
+
+main: () -> int = {
+    test_string: std::string = "The rain in Spain flows mainly down the drain";
+    std::cout << substr<4,8>(test_string) << "\n";
+
+    x: X = test_string;
+    std::cout << x.substr<4,8>() << "\n";
+        // for now this should not be UFCS-ized because of the multiple template arguments
+}

regression-tests/test-results/mixed-ufcs-multiple-template-arguments.cpp

@@ -0,0 +1,34 @@
+// ----- Cpp2 support -----
+#include "cpp2util.h"
+
+#line 1 "mixed-ufcs-multiple-template-arguments.cpp2"
+
+template <auto from, auto to>
+auto substr(const std::string& input) -> std::string {
+    return input.substr(from, to-from);
+}
+
+struct X {
+    std::string input;
+    X(const std::string& input) : input{input} { }
+    template <auto from, auto to>
+    auto substr() -> std::string {
+        return input.substr(from, to-from);
+    }
+};
+
+[[nodiscard]] auto main() -> int;
+
+//=== Cpp2 definitions ==========================================================
+
+#line 15 "mixed-ufcs-multiple-template-arguments.cpp2"
+
+[[nodiscard]] auto main() -> int{
+    std::string test_string { "The rain in Spain flows mainly down the drain" }; 
+    std::cout << substr<4,8>(test_string) << "\n";
+
+    X x { test_string }; 
+    std::cout << std::move(x).substr<4,8>() << "\n";
+        // for now this should not be UFCS-ized because of the multiple template arguments
+}
+

regression-tests/test-results/mixed-ufcs-multiple-template-arguments.cpp2.output

@@ -0,0 +1,2 @@
+mixed-ufcs-multiple-template-arguments.cpp2... ok (mixed Cpp1/Cpp2, Cpp2 code passes safety checks)
+

source/cppfront.cpp

@@ -1684,6 +1684,9 @@ class cppfront
             std::ssize(n.ops) >= 2 &&                   //  and we're of the form:
             n.ops[0].op->type() == lexeme::Dot &&       //       token . id-expr ( expr-list )
             n.ops[1].op->type() == lexeme::LeftParen &&
+            // alpha limitation: if it's a function call with more than one template argument (e.g., x.f<1,2>())
+            //                   the UFCS* macros can't handle that right now, so don't UFCS-size it
+            n.ops[0].id_expr->template_args_count() < 2 &&
             // and either there's nothing after that, or there's just a $ after that
             (
                 std::ssize(n.ops) == 2 ||
@@ -1715,8 +1718,7 @@ class cppfront
             //printer.print_cpp2("CPP2_UFCS(", n.position());
 
             auto ufcs_string = std::string("CPP2_UFCS");
-            //  If we can get the id-expr's token, then the unqualified-id has no template args
-            if (n.ops[0].id_expr->get_token() == nullptr) {
+            if (n.ops[0].id_expr->template_args_count() > 0) {
                 ufcs_string += "_TEMPLATE";
             }
             //  If there are no additional arguments, use the _0 version

source/parse.h

@@ -130,6 +130,7 @@ struct primary_expression_node
         std::unique_ptr<inspect_expression_node>
     > expr;
 
+    auto template_args_count() -> int;
     auto get_token() -> token const*;
     auto position() const -> source_position;
     auto visit(auto& v, int depth) -> void;
@@ -385,6 +386,10 @@ struct unqualified_id_node
     };
     std::vector<term> template_args;
 
+    auto template_args_count() -> int {
+        return std::ssize(template_args);
+    }
+
     auto get_token() -> token const* {
         if (template_args.empty()) {
             assert (identifier);
@@ -469,6 +474,14 @@ struct type_id_node
         std::unique_ptr<unqualified_id_node>
     > id;
 
+    auto template_args_count() -> int {
+        if (id.index() == unqualified) {
+            return std::get<unqualified>(id)->template_args_count();
+        }
+        // else
+        return 0;
+    }
+
     auto get_token() -> token const* {
         if (id.index() == unqualified) {
             return std::get<unqualified>(id)->get_token();
@@ -505,6 +518,14 @@ struct id_expression_node
         std::unique_ptr<unqualified_id_node>
     > id;
 
+    auto template_args_count() -> int {
+        if (id.index() == unqualified) {
+            return std::get<unqualified>(id)->template_args_count();
+        }
+        // else
+        return 0;
+    }
+
     auto get_token() -> token const* {
         if (id.index() == unqualified) {
             return std::get<unqualified>(id)->get_token();
@@ -933,6 +954,14 @@ struct declaration_node
     }
 };
 
+auto primary_expression_node::template_args_count() -> int {
+    if (expr.index() == id_expression) {
+        return std::get<id_expression>(expr)->template_args_count();
+    }
+    // else
+    return 0;
+}
+
 auto primary_expression_node::get_token() -> token const*
 {
     if (expr.index() == identifier) {