Exempt the is_convertible check from P2748 and diagnose references to members of temporaries. [GH #106]

Author: mohitmishra786

src/exprutil.c

@@ -25254,13 +25254,14 @@ that identifies an object or a prvalue that is a pointer to an object.
 }  /* examine_expr_for_auto_object */
 
 
-a_boolean is_glvalue_for_auto_object(an_expr_node_ptr expr,
-                                     a_boolean        *is_temp)
+static a_boolean glvalue_for_auto_object(an_expr_node_ptr expr,
+                                         a_boolean        follow_prvalues,
+                                         a_boolean        *is_temp)
 /*
-Return TRUE if expr is a glvalue whose underlying object is known to
-be an automatic (stack-based) entity.  The safe answer is FALSE.  If the
-underlying entity is a temporary, return *is_temp set to TRUE.  
-is_temp can be NULL if that information is not needed.
+Do the work for is_glvalue_for_auto_object and
+is_glvalue_for_auto_object_or_temp_subobject.  If follow_prvalues is TRUE,
+the traversal continues through class prvalues, so that a subobject of a
+temporary (e.g., "S().x") is found.
 */
 {
   a_boolean is_auto_object = FALSE;
@@ -25271,14 +25272,41 @@ is_temp can be NULL if that information is not needed.
     clear_expr_or_stmt_traversal_block(&tblock);
     tblock.process_expr = examine_expr_for_auto_object;
     tblock.follow_addressing_path = TRUE;
+    tblock.follow_class_rvalue_addressing_path = follow_prvalues;
     traverse_expr(expr, &tblock);
     is_auto_object = tblock.result;
     if (is_temp != NULL) *is_temp = tblock.is_temp;
   }  /* if */
   return is_auto_object;
+}  /* glvalue_for_auto_object */
+
+
+a_boolean is_glvalue_for_auto_object(an_expr_node_ptr expr,
+                                     a_boolean        *is_temp)
+/*
+Return TRUE if expr is a glvalue whose underlying object is known to
+be an automatic (stack-based) entity.  The safe answer is FALSE.  If the
+underlying entity is a temporary, return *is_temp set to TRUE.  
+is_temp can be NULL if that information is not needed.
+*/
+{
+  return glvalue_for_auto_object(expr, /*follow_prvalues=*/FALSE, is_temp);
 }  /* is_glvalue_for_auto_object */
 
 
+a_boolean is_glvalue_for_auto_object_or_temp_subobject(
+                                                   an_expr_node_ptr expr,
+                                                   a_boolean        *is_temp)
+/*
+Like is_glvalue_for_auto_object, but also return TRUE (with *is_temp set to
+TRUE) if expr is a glvalue for a subobject of a class prvalue temporary,
+e.g., "S().x".
+*/
+{
+  return glvalue_for_auto_object(expr, /*follow_prvalues=*/TRUE, is_temp);
+}  /* is_glvalue_for_auto_object_or_temp_subobject */
+
+
 a_boolean is_prvalue_for_auto_object(an_expr_node_ptr expr,
                                      a_boolean        *is_temp)
 /*

src/exprutil.h

@@ -3149,6 +3149,10 @@ extern a_boolean still_an_lvalue(a_type_ptr type_before_cast,
 extern a_boolean is_glvalue_for_auto_object(an_expr_node_ptr expr,
                                              a_boolean        *is_temp);
 
+extern a_boolean is_glvalue_for_auto_object_or_temp_subobject(
+                                                   an_expr_node_ptr expr,
+                                                   a_boolean        *is_temp);
+
 extern a_boolean is_prvalue_for_auto_object(an_expr_node_ptr expr,
                                             a_boolean        *is_temp);
 

src/overload.c

@@ -25440,11 +25440,12 @@ a temporary found here only gets the warning.
   a_boolean is_temp;
 
   if (is_expression_operand(operand)) {
-    if (is_glvalue_for_auto_object(operand->variant.expression, &is_temp) ||
+    if (is_glvalue_for_auto_object_or_temp_subobject(
+                                    operand->variant.expression, &is_temp) ||
         is_prvalue_for_auto_object(operand->variant.expression, &is_temp)) {
       /* The expression is a glvalue or class prvalue (object) for a local
-         entity.  Use a different message for temporaries and local
-         variables. */
+         entity (possibly a subobject of a temporary).  Use a different
+         message for temporaries and local variables. */
       if (!is_temp) {
         expr_pos_warning(ec_returning_ref_to_local_variable,
                          &operand->position);
@@ -26335,8 +26336,12 @@ the conversion.
                                     source_operand,
                                     (conv_context & CCO_STATIC_LIFETIME) != 0);
   } else if ((conv_context & CCO_INITIALIZING_RETURN_VALUE) &&
+             (conv_context & CCO_TYPE_TRAITS_CHECK) == 0 &&
              !template_case) {
-    /* Check for returning a reference to a local entity. */
+    /* Check for returning a reference to a local entity.  This is not done
+       for the invented function of the is_convertible check: P2748, which
+       makes binding a returned reference to a temporary ill-formed in C++26,
+       does not apply to it. */
     check_for_returning_reference_to_local_entity(source_operand,
                                                   similar_lvalue_source);
   }  /* if */

src/pending_changes/gh-106-return-ref-to-temporary.txt

@@ -6,6 +6,15 @@ allowed in C++26 (P2748).  The front end only issued a warning.  It is now an
 error in C++26 (still a warning when emulating GCC versions before 14 or
 Clang versions before 19, which do the same).  For example, with --c++26:
 
-  const int& f() { return 1; }  // Now an error.
+  struct S { int x; };
+  const int& f() { return 1; }      // Now an error.
+  const int& g() { return S().x; }  // Now an error.
 
-Returning a reference to a local variable is still only a warning.
+Returning a reference to a member of a temporary, as in g, was previously not
+diagnosed at all in the standard (non-GNU, non-Clang) modes; before C++26 it
+now gets the same warning as the other cases.  Returning a reference to a
+local variable is still only a warning.
+
+As P2748 specifies, this does not apply to the conversion checked by
+std::is_convertible (e.g., __is_convertible_to(long, const int&) is still
+true).

tests/tests/changes/.GH106.rto/default.1.1.txt

@@ -7,6 +7,10 @@ fe_only -DTEST_NUMBER=1 --c++26 Test_name.c
   const int& f2(long l) { return l; }       // Temporary from a conversion.
                                  ^
 
+"Test_name.c", line 13: error: returning reference to local temporary
+  const int& f3() { return S().x; }         // Member of a temporary.
+                           ^
+
 "Test_name.c", line 14: error: returning reference to local temporary
   int&& f4() { return 1; }                  // Rvalue reference to a temporary.
                       ^
@@ -15,4 +19,4 @@ fe_only -DTEST_NUMBER=1 --c++26 Test_name.c
   const int& f5() { int i = 0; return i; }  // Local variable: only a warning.
                                       ^
 
-3 errors detected in the compilation of "Test_name.c".
+4 errors detected in the compilation of "Test_name.c".

tests/tests/changes/.GH106_a.rto/default.1.1.txt

@@ -7,6 +7,10 @@ fe_only -DTEST_NUMBER=1 --c++23 Test_name.c
   const int& f2(long l) { return l; }       // Temporary from a conversion.
                                  ^
 
+"Test_name.c", line 12: warning: returning reference to local temporary
+  const int& f3() { return S().x; }         // Member of a temporary.
+                           ^
+
 "Test_name.c", line 13: warning: returning reference to local temporary
   int&& f4() { return 1; }                  // Rvalue reference to a temporary.
                       ^

tests/tests/changes/GH106.sft.cpp

@@ -18,3 +18,8 @@ const int& f5() { int i = 0; return i; }  // Local variable: only a warning.
 // diagnosed as an error.
 int **pp;
 const int *const *const &f6() { return pp; }
+
+// P2748 does not apply to the invented function used for is_convertible.
+static_assert(__is_convertible_to(int, const int&), "");
+static_assert(__is_convertible_to(long, const int&), "");
+static_assert(__is_convertible_to(S, const S&), "");

tests/tests/changes/GH106_a.sft.cpp

@@ -17,3 +17,8 @@ const int& f5() { int i = 0; return i; }  // Local variable: only a warning.
 // diagnosed as an error.
 int **pp;
 const int *const *const &f6() { return pp; }
+
+// P2748 does not apply to the invented function used for is_convertible.
+static_assert(__is_convertible_to(int, const int&), "");
+static_assert(__is_convertible_to(long, const int&), "");
+static_assert(__is_convertible_to(S, const S&), "");