Remove last traces of discard_all_inferiors

[deliverable/binutils-gdb.git] / gdb / d-namespace.c

diff --git a/gdb/d-namespace.c b/gdb/d-namespace.c
index bc791f70dcaf4df85f301b2c18047fda13e6c0e1..de27ab779a019a41d556d1d570e79855edfe58fa 100644 (file)
--- a/gdb/d-namespace.c
+++ b/gdb/d-namespace.c
@@ -1,6 +1,6 @@
 /* Helper routines for D support in GDB.
 
-   Copyright (C) 2014-2017 Free Software Foundation, Inc.
+   Copyright (C) 2014-2020 Free Software Foundation, Inc.
 
    This file is part of GDB.
 
@@ -24,6 +24,7 @@
 #include "namespace.h"
 #include "d-lang.h"
 #include "gdb_obstack.h"
+#include "gdbarch.h"
 
 /* This returns the length of first component of NAME, which should be
    the demangled name of a D variable/function/method/etc.
@@ -127,7 +128,7 @@ d_lookup_symbol (const struct language_defn *langdef,
 
          lang_this = lookup_language_this (language_def (language_d), block);
          if (lang_this.symbol == NULL)
-           return null_block_symbol;
+           return {};
 
          type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this.symbol)));
          classname = TYPE_NAME (type);
@@ -147,7 +148,7 @@ d_lookup_symbol (const struct language_defn *langdef,
         more that can be done.  */
       class_sym = lookup_global_symbol (classname.c_str (), block, domain);
       if (class_sym.symbol == NULL)
-       return null_block_symbol;
+       return {};
 
       /* Look for a symbol named NESTED in this class.  */
       sym = d_lookup_nested_symbol (SYMBOL_TYPE (class_sym.symbol),
@@ -246,12 +247,9 @@ static struct block_symbol
 find_symbol_in_baseclass (struct type *parent_type, const char *name,
                          const struct block *block)
 {
-  struct block_symbol sym;
+  struct block_symbol sym = {};
   int i;
 
-  sym.symbol = NULL;
-  sym.block = NULL;
-
   for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
     {
       struct type *base_type = TYPE_BASECLASS (parent_type, i);
@@ -318,7 +316,7 @@ d_lookup_nested_symbol (struct type *parent_type,
     case TYPE_CODE_MODULE:
        {
          int size;
-         const char *parent_name = type_name_no_tag_or_error (saved_parent_type);
+         const char *parent_name = type_name_or_error (saved_parent_type);
          struct block_symbol sym
            = d_lookup_symbol_in_module (parent_name, nested_name,
                                         block, VAR_DOMAIN, 0);
@@ -349,23 +347,13 @@ d_lookup_nested_symbol (struct type *parent_type,
 
     case TYPE_CODE_FUNC:
     case TYPE_CODE_METHOD:
-      return null_block_symbol;
+      return {};
 
     default:
       gdb_assert_not_reached ("called with non-aggregate type.");
     }
 }
 
-/* Used for cleanups to reset the "searched" flag incase
-   of an error.  */
-
-static void
-reset_directive_searched (void *data)
-{
-  struct using_direct *direct = (struct using_direct *) data;
-  direct->searched = 0;
-}
-
 /* Search for NAME by applying all import statements belonging to
    BLOCK which are applicable in SCOPE.  */
 
@@ -376,7 +364,6 @@ d_lookup_symbol_imports (const char *scope, const char *name,
 {
   struct using_direct *current;
   struct block_symbol sym;
-  struct cleanup *searched_cleanup;
 
   /* First, try to find the symbol in the given module.  */
   sym = d_lookup_symbol_in_module (scope, name, block, domain, 1);
@@ -399,9 +386,8 @@ d_lookup_symbol_imports (const char *scope, const char *name,
        {
          /* Mark this import as searched so that the recursive call
             does not search it again.  */
-         current->searched = 1;
-         searched_cleanup = make_cleanup (reset_directive_searched,
-                                          current);
+         scoped_restore restore_searched
+           = make_scoped_restore (&current->searched, 1);
 
          /* If there is an import of a single declaration, compare the
             imported declaration (after optional renaming by its alias)
@@ -419,9 +405,6 @@ d_lookup_symbol_imports (const char *scope, const char *name,
             declaration, the search of this import is complete.  */
          if (sym.symbol != NULL || current->declaration)
            {
-             current->searched = 0;
-             discard_cleanups (searched_cleanup);
-
              if (sym.symbol != NULL)
                return sym;
 
@@ -433,10 +416,7 @@ d_lookup_symbol_imports (const char *scope, const char *name,
            if (strcmp (name, *excludep) == 0)
              break;
          if (*excludep)
-           {
-             discard_cleanups (searched_cleanup);
-             continue;
-           }
+           continue;
 
          /* If the import statement is creating an alias.  */
          if (current->alias != NULL)
@@ -476,15 +456,13 @@ d_lookup_symbol_imports (const char *scope, const char *name,
              sym = d_lookup_symbol_in_module (current->import_src,
                                               name, block, domain, 1);
            }
-         current->searched = 0;
-         discard_cleanups (searched_cleanup);
 
          if (sym.symbol != NULL)
            return sym;
        }
     }
 
-  return null_block_symbol;
+  return {};
 }
 
 /* Searches for NAME in the current module, and by applying relevant
@@ -516,7 +494,7 @@ d_lookup_symbol_module (const char *scope, const char *name,
       block = BLOCK_SUPERBLOCK (block);
     }
 
-  return null_block_symbol;
+  return {};
 }
 
 /* The D-specific version of name lookup for static and global names