Bind an NSDMI's implicit this to the right aggregate [GH #324]

When lowering a non-constant aggregate initialization, lower_param_ref
replaced the enk_param_ref for "this" with the innermost aggregate on
aggregate_this_stack whose type matched.  A default member initializer
that aggregate-initializes another object of the same class then bound
the implicit "this" of its explicit elements to that nested object:

  struct Y { unsigned k; unsigned n = Y{2, k}.n; };
  Y *p = new Y{1};  // p->n was 2, not 1.

Only an element that comes from a default member initializer (marked
implicit_aggr_element) can refer to the aggregate it initializes, which
is also the rule the constexpr interpreter uses.  An aggregate is now
skipped in the search while one of its explicit elements is lowered;
if nothing else matches, the previous search is used.

Author: Momen-G-Ar

src/lower_il.c

@@ -15971,6 +15971,73 @@ lowering).  Note that eok_class_rvalue_adjust operations are not modified here
 }  /* remove_qualifiers_from_expr_type_if_needed */
 
 
+static a_boolean replace_param_ref_with_aggregate_this(
+                                         an_expr_node_ptr expr,
+                                         a_boolean        candidates_only)
+/*
+expr is an enk_param_ref node that represents "this" while lowering an
+aggregate constant.  Go backwards through aggregate_this_stack, the stack of
+nested potential "this" pointers, looking for the innermost entry that
+matches the type of expr.  If candidates_only is TRUE, skip the entries
+whose not_this_candidate flag is set (see
+lower_dynamic_init_aggregate_constant).  If an entry is found, replace expr
+by an expression that points to the beginning of that aggregate and return
+TRUE; otherwise, return FALSE.  Note that the code below is inefficient in
+that it creates an expression representation for the initialization position
+description just to find out its type (and discards expression trees that
+don't match), but the type is difficult to determine (because of potential
+modifiers) and this case doesn't occur frequently.
+*/
+{
+  a_boolean             found = FALSE;
+  an_expr_node_ptr      new_expr = NULL;
+  an_init_pos_descr_ptr ipdp;
+  a_type_ptr            new_type,
+                        old_type= skip_typerefs(type_pointed_to(expr->type));
+
+  for (ipdp = aggregate_this_stack; ipdp != NULL; ipdp = ipdp->next) {
+    a_type_ptr subobj_type;
+    if (candidates_only && ipdp->not_this_candidate) {
+      /* An explicitly specified element of this aggregate is being lowered,
+         so this aggregate is not what "this" refers to. */
+      continue;
+    }  /* if */
+    new_expr = make_address_of_init_entity_node(ipdp,
+                                                /*using_as_dest=*/FALSE);
+    new_type = skip_typerefs(type_pointed_to(new_expr->type));
+    if (identical_types_ignoring_qualifiers(new_type, old_type) ||
+        (aggregate_classes_can_have_bases &&
+         !class_type_supp(old_type)->is_lambda_closure_class &&
+         !class_type_supp(new_type)->is_lambda_closure_class &&
+         (subobj_type = subobject_for_class(old_type),
+          identical_types_ignoring_qualifiers(new_type, subobj_type)))) {
+      found = TRUE;
+      new_expr = add_cast_if_necessary(new_expr, expr->type);
+      overwrite_node(expr, new_expr);
+      break;
+    } else if (aggregate_classes_can_have_bases &&
+               ipdp->base_class_subobject) {
+      /* See if this initialization position has been modified to point
+         to a subobject base class.  If so, temporarily remove the modifier
+         to see if the non-modified type is the "this" type that we're
+         looking for. */
+      an_init_pos_modifier_ptr save_modifiers = ipdp->modifiers;
+      ipdp->modifiers = NULL;
+      new_expr = make_address_of_init_entity_node(ipdp,
+                                                  /*using_as_dest=*/FALSE);
+      new_type = type_pointed_to(new_expr->type);
+      ipdp->modifiers = save_modifiers;
+      if (identical_types_ignoring_qualifiers(new_type, old_type)) {
+        found = TRUE;
+        overwrite_node(expr, new_expr);
+        break;
+      }  /* if */
+    }  /* if */
+  }  /* for */
+  return found;
+}  /* replace_param_ref_with_aggregate_this */
+
+
 static void lower_param_ref(an_expr_node_ptr expr)
 /*
 The front end uses enk_param_refs to represent "this" in two particular
@@ -16001,60 +16068,26 @@ as in this case:
   } a;
 
 If we're in a non-constant aggregate initialization, search for that first.
+Several nested aggregates can have the type of "this", as in:
+
+  struct Y { unsigned k; unsigned n = Y{2, k}.n; };
+
+where "k" refers to the Y being initialized, not to the temporary
+initialized by "Y{2, k}".  The aggregates for which an explicitly specified
+element is being lowered are therefore skipped.
 */
 {
   a_boolean found = FALSE;
 
   check_assertion(expr->kind == (an_expr_node_kind)enk_param_ref &&
                   expr->variant.param_ref.param_num == 0);
   if (aggregate_this_stack != NULL) {
-    /* We must be lowering an aggregate constant; go backwards through the
-       stack of nested potential "this" pointers looking for one that matches
-       the type of the enk_param_ref node (there can only be one) and
-       create an expression that points to the beginning of that aggregate.
-       Note that the code below is inefficient in that it creates an
-       expression representation for the initialization position description
-       just to find out its type (and discards expression trees that don't
-       match), but the type is difficult to determine (because of potential
-       modifiers) and this case doesn't occur frequently. */
-    an_expr_node_ptr      new_expr = NULL;
-    an_init_pos_descr_ptr ipdp;
-    a_type_ptr            new_type,
-                          old_type= skip_typerefs(type_pointed_to(expr->type));
-    for (ipdp = aggregate_this_stack; ipdp != NULL; ipdp = ipdp->next) {
-      a_type_ptr subobj_type;
-      new_expr = make_address_of_init_entity_node(ipdp,
-                                                  /*using_as_dest=*/FALSE);
-      new_type = skip_typerefs(type_pointed_to(new_expr->type));
-      if (identical_types_ignoring_qualifiers(new_type, old_type) ||
-          (aggregate_classes_can_have_bases &&
-           !class_type_supp(old_type)->is_lambda_closure_class &&
-           !class_type_supp(new_type)->is_lambda_closure_class &&
-           (subobj_type = subobject_for_class(old_type),
-            identical_types_ignoring_qualifiers(new_type, subobj_type)))) {
-        found = TRUE;
-        new_expr = add_cast_if_necessary(new_expr, expr->type);
-        overwrite_node(expr, new_expr);
-        break;
-      } else if (aggregate_classes_can_have_bases &&
-                 ipdp->base_class_subobject) {
-        /* See if this initialization position has been modified to point
-           to a subobject base class.  If so, temporarily remove the modifier
-           to see if the non-modified type is the "this" type that we're
-           looking for. */
-        an_init_pos_modifier_ptr save_modifiers = ipdp->modifiers;
-        ipdp->modifiers = NULL;
-        new_expr = make_address_of_init_entity_node(ipdp,
-                                                    /*using_as_dest=*/FALSE);
-        new_type = type_pointed_to(new_expr->type);
-        ipdp->modifiers = save_modifiers;
-        if (identical_types_ignoring_qualifiers(new_type, old_type)) {
-          found = TRUE;
-          overwrite_node(expr, new_expr);
-          break;
-        }  /* if */
-      }  /* if */
-    }  /* for */
+    /* We must be lowering an aggregate constant.  If no candidate aggregate
+       matches, fall back on all the aggregates on the stack. */
+    found = replace_param_ref_with_aggregate_this(expr,
+                                                  /*candidates_only=*/TRUE) ||
+            replace_param_ref_with_aggregate_this(expr,
+                                                  /*candidates_only=*/FALSE);
   }  /* if */
   if (!found) {
     if (ctor_init_this != NULL) {

src/lower_il.h

@@ -220,6 +220,13 @@ typedef struct an_init_pos_descr {
 			   to indicate that the derived class is a complete
 			   object, which allows more efficient addressing of
 			   virtual base classes. */
+  a_byte_boolean
+		not_this_candidate;
+			/* TRUE while an explicitly specified element of the
+			   aggregate that begins at this position is being
+			   lowered.  Such an element cannot refer to that
+			   aggregate through an implicit "this" (see
+			   lower_param_ref). */
   a_type_ptr	base_type;
 			/* Base entity type. */
   an_init_pos_modifier_ptr

src/lower_init.c

@@ -1126,6 +1126,7 @@ Clear an initialization position description entry to default values.
   ipdp->array_element_sequence    = FALSE;
   ipdp->base_class_subobject      = FALSE;
   ipdp->base_of_complete_object   = FALSE;
+  ipdp->not_this_candidate        = FALSE;
   ipdp->base_type                 = NULL;
   ipdp->modifiers                 = NULL;
   ipdp->array_element_count       = 0;
@@ -6301,6 +6302,18 @@ Pop the top entry from aggregate_this_stack.
 }  /* pop_aggregate_this */
 
 
+static a_boolean is_anonymous_union_class(a_type_ptr type)
+/*
+Return TRUE if type is the class type of an anonymous union.
+*/
+{
+  type = skip_typerefs(type);
+  return is_immediate_class_type(type) &&
+         class_type_supp(type)->anonymous_union_kind !=
+                                            (an_anonymous_union_kind)auk_none;
+}  /* is_anonymous_union_class */
+
+
 static a_boolean has_aggregate_with_dynamic(a_constant_ptr con)
 /*
 Returns TRUE if the constant includes (at some level) an aggregate that
@@ -6730,6 +6743,17 @@ dealt with).
         ipmp->curr_field = curr_field;
         ipmp->type = curr_field->type;
       }  /* if */
+      /* An implicit "this" in the initializer of an element refers to this
+         aggregate only if the element comes from a default member
+         initializer (i.e., it is implicit); an explicitly specified element
+         refers to the "this" of the enclosing context, as in:
+           struct Y { unsigned k; unsigned n = Y{2, k}.n; };
+         where "k" in "Y{2, k}" designates the outer Y, not the temporary.
+         The default member initializers of the members of an anonymous
+         union refer to the enclosing class, so an anonymous union does not
+         affect the search. */
+      ipdp->not_this_candidate = !con_ptr->implicit_aggr_element &&
+                                 !is_anonymous_union_class(aggr_type);
     }  /* if */
     /* Initialize one member of the aggregate (of type ipmp->type) with
        one constant (con_ptr). */
@@ -7051,7 +7075,10 @@ dealt with).
   if (!aggr_const->is_partially_initialized) {
     (void)recompute_partially_initialized_flag(aggr_const, aggr_type);
   }  /* if */
-  if (!array_or_vector) pop_aggregate_this();
+  if (!array_or_vector) {
+    ipdp->not_this_candidate = FALSE;
+    pop_aggregate_this();
+  }  /* if */
 }  /* lower_dynamic_init_aggregate_constant */
 
 #if USE_PATCH_INIT_STARTUP

src/pending_changes/gh-324-nsdmi-this-nested-aggregate.txt

@@ -0,0 +1,14 @@
+[GH #324]
+Implicit "this" in a default member initializer with a nested aggregate
+
+When the default member initializer of an aggregate class contained an
+aggregate initialization of another object of the same class, an implicit use
+of "this" in the elements of that nested initialization referred to the
+nested object instead of to the object being initialized.  This affected
+initializations that are not folded to constants, such as those in
+new-expressions or return statements.  For example:
+
+  struct Y { unsigned k; unsigned n = Y{2, k}.n; };
+  Y *p = new Y{1};  // p->n is now 1 (previously 2).
+
+This is now fixed.

tests/expectations/edg_x86_64/imported.log

@@ -6814,7 +6814,6 @@ gnu/cpp/cpp1y/pr61636-3.sft.cpp:fn:-DTEST_NUMBER=1 --c++14:FAIL:
 gnu/cpp/cpp1y/pr68180.sft.cpp:fn:-DTEST_NUMBER=1 --c++14:FAIL:
 gnu/cpp/cpp1y/pr79435.sft.cpp:fn:-DTEST_NUMBER=1 --c++14:FAIL:
 gnu/cpp/cpp1y/pr79463.sft.cpp:fn:-DTEST_NUMBER=1 --c++14:FAIL:
-gnu/cpp/cpp1y/pr79937-4.sft.cpp:rp:-DTEST_NUMBER=1 --c++14:FAIL:
 gnu/cpp/cpp1y/sized-dealloc2/test.mft.cpp:fp:-DTEST_NUMBER=1:FAIL:
 gnu/cpp/cpp1y/udlit-char-template-sfinae-neg.sft.cpp:fn:-DTEST_NUMBER=1 --c++14:ABORT:
 gnu/cpp/cpp1y/var-templ20.sft.cpp:fn:-DTEST_NUMBER=1 --c++14:FAIL:

tests/tests/regressions/.gh-324.rto/default.1.1.txt

@@ -0,0 +1 @@
+eccp -DTEST_NUMBER=1 --c++20 Test_name.c

tests/tests/regressions/.gh-324.rto/default.1.2.txt

@@ -0,0 +1 @@
+./a.out

tests/tests/regressions/.gh-324.rto/default.2.1.txt

@@ -0,0 +1 @@
+eccp -DTEST_NUMBER=2 --c++20 --g++ --gnu_version=150000 Test_name.c

tests/tests/regressions/.gh-324.rto/default.2.2.txt

@@ -0,0 +1 @@
+./a.out

tests/tests/regressions/.gh-324.rto/default.3.1.txt

@@ -0,0 +1 @@
+eccp -DTEST_NUMBER=3 --c++20 --clang Test_name.c