fix(cpp1): improve recognition of value-dependent expressions

Author: JohelEGP

regression-tests/pure2-bugfix-for-dependent-types.cpp2

@@ -11,6 +11,7 @@ f: <T, V: T::value_type> (x: T::value_type) -> T::value_type = {
   _ = :identity<T>::value_type = ();      // First identifier.
   _ = :std::optional<T>::value_type = (); // Non-first identifier.
   _ = :std::array<i32, T::value>::value_type = ();
+  _ = :std::array<i32, T::value + T::value>::value_type = ();
 
   // Emitted `template`.
   ptr: type  == * T;                                 // Needed, pending #502.

regression-tests/test-results/pure2-bugfix-for-dependent-types.cpp

@@ -7,7 +7,7 @@
 #include "cpp2util.h"
 
 
-#line 47 "pure2-bugfix-for-dependent-types.cpp2"
+#line 48 "pure2-bugfix-for-dependent-types.cpp2"
 template<typename T> class t;
 
 
@@ -19,14 +19,14 @@ template<typename T> using identity = T;
 template<typename T, T::value_type V> [[nodiscard]] auto f(cpp2::in<typename T::value_type> x) -> T::value_type;
 
 
-#line 47 "pure2-bugfix-for-dependent-types.cpp2"
+#line 48 "pure2-bugfix-for-dependent-types.cpp2"
 template<typename T> class t {
 struct u_x_as_base { T::value_type x; };
 
-#line 48 "pure2-bugfix-for-dependent-types.cpp2"
+#line 49 "pure2-bugfix-for-dependent-types.cpp2"
   public: class u: public u_x_as_base, public T::type {
 
-#line 51 "pure2-bugfix-for-dependent-types.cpp2"
+#line 52 "pure2-bugfix-for-dependent-types.cpp2"
   };
   public: T::value_type x {0}; 
 };
@@ -49,6 +49,7 @@ template<typename T, T::value_type V> [[nodiscard]] auto f(cpp2::in<typename T::
   (void) typename identity<T>::value_type{};// First identifier.
   (void) typename std::optional<T>::value_type{};// Non-first identifier.
   (void) typename std::array<cpp2::i32,T::value>::value_type{};
+  (void) typename std::array<cpp2::i32,T::value + T::value>::value_type{};
 
   // Emitted `template`.
   using ptr = T*;                                    // Needed, pending #502.
@@ -82,7 +83,7 @@ template<typename T, T::value_type V> [[nodiscard]] auto f(cpp2::in<typename T::
   }
 }
 
-#line 55 "pure2-bugfix-for-dependent-types.cpp2"
+#line 56 "pure2-bugfix-for-dependent-types.cpp2"
 auto main() -> int{
   using zero = std::integral_constant<cpp2::i32,0>;
   (void) f<zero,0>(0);

source/cppfront.cpp

@@ -1819,6 +1819,121 @@ class cppfront
         return false;
     }
 
+    struct is_dependent_expression_visitor {
+        cppfront* self;
+
+        auto operator()(expression_node const& expr) const
+            -> bool
+        {
+            return (*this)(*expr.expr);
+        }
+
+        template<String Name, typename Term>
+        auto operator()(binary_expression_node<Name, Term> const& expr) const
+            -> bool
+        {
+            return (*this)(*expr.expr) || std::any_of(expr.terms.begin(), expr.terms.end(), *this);
+        }
+
+        template<class BinaryExpressionTerm>
+        auto operator()(BinaryExpressionTerm const& term) const
+            -> bool
+            requires requires { term.op; term.expr; }
+        {
+            return (*this)(*term.expr);
+        }
+
+        auto operator()(is_as_expression_node const& expr) const
+            -> bool
+        {
+            return (*this)(*expr.expr) || std::any_of(expr.ops.begin(), expr.ops.end(), *this);
+        }
+
+        auto operator()(is_as_expression_node::term const& expr) const
+            -> bool
+        {
+            if (expr.expr) {
+                return (*this)(*expr.expr);
+            }
+            return self->is_dependent(*expr.type);
+        }
+
+        auto operator()(prefix_expression_node const& expr) const
+            -> bool
+        {
+            return (*this)(*expr.expr);
+        }
+
+        auto operator()(postfix_expression_node const& expr) const
+            -> bool
+        {
+            return (*this)(*expr.expr) || std::any_of(expr.ops.begin(), expr.ops.end(), *this);
+        }
+
+        auto operator()(postfix_expression_node::term const& expr) const
+            -> bool
+        {
+            if (expr.id_expr) {
+                return (*this)(*expr.id_expr);
+            }
+            return (*this)(*expr.expr_list);
+        }
+
+        auto operator()(primary_expression_node const& expr) const
+            -> bool
+        {
+            return std::visit([&]<typename T>(T const& expr) {
+                if constexpr (std::is_same_v<T, std::monostate>
+                              || std::is_same_v<T, token const*>
+                              || std::is_same_v<T, std::unique_ptr<literal_node>>) {
+                    return false;
+                } else {
+                    return (*this)(*expr);
+                }
+            }, expr.expr);
+        }
+
+        auto operator()(expression_list_node const& expr) const
+            -> bool
+        {
+            return std::any_of(expr.expressions.begin(), expr.expressions.end(), *this);
+        }
+
+        auto operator()(expression_list_node::term const& term) const
+            -> bool
+        {
+            return (*this)(*term.expr);
+        }
+
+        auto operator()(id_expression_node const& expr) const
+            -> bool
+        {
+            return std::visit([&]<typename T>(T const& expr) {
+                if constexpr (std::is_same_v<T, std::monostate>) {
+                    return false;
+                } else {
+                    return self->is_dependent(*expr);
+                }
+            }, expr.id);
+        }
+
+        auto operator()(declaration_node const& n) const
+            -> bool
+        {
+            auto& type_id = std::get<declaration_node::an_object>(n.type);
+            if (type_id->is_wildcard()) {
+                return false; // (*this)(*term.initializer);
+            }
+            return self->is_dependent(*type_id);
+        }
+
+        auto operator()(inspect_expression_node const& expr) const
+            -> bool
+        {
+            return self->is_deducible(*expr.result_type);
+        }
+    };
+
     auto is_dependent(
         const unqualified_id_node& n,
         bool /*is_qualified*/ = false,
@@ -1835,13 +1950,9 @@ class cppfront
             assert(n.identifier);
             // and any of its template arguments is either
             return std::any_of(n.template_args.begin(), n.template_args.end(), [&](unqualified_id_node::term const& arg) {
-                if (auto expr = get_if<unqualified_id_node::expression>(&arg.arg);
-                    expr && (*expr)->is_id_expression()) {
-                    // a dependent _id-expression_
-                    auto& pid = (*expr)->expr->expr->expr->expr->expr->expr->expr->expr->expr->expr->expr->expr->expr->expr->expr->expr->expr;
-                    if (auto id = get_if<primary_expression_node::id_expression>(&pid)) {
-                        return is_dependent(**id);
-                    }
+                if (auto expr = get_if<unqualified_id_node::expression>(&arg.arg)) {
+                    // a dependent _expression_
+                    return is_dependent_expression_visitor{this}(**expr);
                 }
                 else if (auto type_id = get_if<unqualified_id_node::type_id>(&arg.arg)) {
                     // or a dependent _type-id_.