d: Factor d_nested_class and d_nested_struct into single function.

Both do the exact same operation, just on different AST nodes.

gcc/d/ChangeLog:

	* d-codegen.cc (d_nested_class): Rename to ...
	(get_outer_function): ... this.  Handle all aggregate declarations.
	(d_nested_struct): Remove.
	(find_this_tree): Use get_outer_function.
	(get_framedecl): Likewise.

diff --git a/gcc/d/d-codegen.cc b/gcc/d/d-codegen.cc
index f35de90b54c2a1ff8c5ad3063ff3b59a47ae9842..fe2ad98e60ae8ecbe8c9fcfef0be9506700ff0b8 100644 (file)
--- a/gcc/d/d-codegen.cc
+++ b/gcc/d/d-codegen.cc
@@ -2354,41 +2354,24 @@ get_frame_for_symbol (Dsymbol *sym)
   return null_pointer_node;
 }
 
-/* Return the parent function of a nested class CD.  */
+/* Return the parent function of a nested class or struct AD.  */
 
 static FuncDeclaration *
-d_nested_class (ClassDeclaration *cd)
+get_outer_function (AggregateDeclaration *ad)
 {
   FuncDeclaration *fd = NULL;
-  while (cd && cd->isNested ())
+  while (ad && ad->isNested ())
     {
-      Dsymbol *dsym = cd->toParent2 ();
+      Dsymbol *dsym = ad->toParent2 ();
       if ((fd = dsym->isFuncDeclaration ()))
        return fd;
       else
-       cd = dsym->isClassDeclaration ();
+       ad = dsym->isAggregateDeclaration ();
     }
-  return NULL;
-}
-
-/* Return the parent function of a nested struct SD.  */
 
-static FuncDeclaration *
-d_nested_struct (StructDeclaration *sd)
-{
-  FuncDeclaration *fd = NULL;
-  while (sd && sd->isNested ())
-    {
-      Dsymbol *dsym = sd->toParent2 ();
-      if ((fd = dsym->isFuncDeclaration ()))
-       return fd;
-      else
-       sd = dsym->isStructDeclaration ();
-    }
   return NULL;
 }
 
-
 /* Starting from the current function FD, try to find a suitable value of
    `this' in nested function instances.  A suitable `this' value is an
    instance of OCD or a class that has OCD as a base.  */
@@ -2411,18 +2394,17 @@ find_this_tree (ClassDeclaration *ocd)
            return convert_expr (get_decl_tree (fd->vthis),
                                 cd->type, ocd->type);
 
-         fd = d_nested_class (cd);
+         fd = get_outer_function (cd);
+         continue;
        }
-      else
-       {
-         if (fd->isNested ())
-           {
-             fd = fd->toParent2 ()->isFuncDeclaration ();
-             continue;
-           }
 
-         fd = NULL;
+      if (fd->isNested ())
+       {
+         fd = fd->toParent2 ()->isFuncDeclaration ();
+         continue;
        }
+
+      fd = NULL;
     }
 
   return NULL_TREE;
@@ -2760,10 +2742,6 @@ get_framedecl (FuncDeclaration *inner, FuncDeclaration *outer)
 
   while (fd && fd != outer)
     {
-      AggregateDeclaration *ad;
-      ClassDeclaration *cd;
-      StructDeclaration *sd;
-
       /* Parent frame link is the first field.  */
       if (FRAMEINFO_CREATES_FRAME (get_frameinfo (fd)))
        result = indirect_ref (ptr_type_node, result);
@@ -2773,12 +2751,8 @@ get_framedecl (FuncDeclaration *inner, FuncDeclaration *outer)
       /* The frame/closure record always points to the outer function's
         frame, even if there are intervening nested classes or structs.
         So, we can just skip over these.  */
-      else if ((ad = fd->isThis ()) && (cd = ad->isClassDeclaration ()))
-       fd = d_nested_class (cd);
-      else if ((ad = fd->isThis ()) && (sd = ad->isStructDeclaration ()))
-       fd = d_nested_struct (sd);
       else
-       break;
+       fd = get_outer_function (fd->isThis ());
     }
 
   if (fd != outer)