gdb: introduce iterator_range, remove next_adapter

I was always a bit confused by next_adapter, because it kind of mixes
the element type and the iterator type.  In reality, it is not much more
than a class that wraps two iterators (begin and end).  However, it
assumes that:

 - you can construct the begin iterator by passing a pointer to the
   first element of the iterable
 - you can default-construct iterator to make the end iterator

I think that by generalizing it a little bit, we can re-use it at more
places.

Rename it to "iterator_range".  I think it describes a bit better: it's
a range made by wrapping a begin and end iterator.  Move it to its own
file, since it's not related to next_iterator anymore.

iterator_range has two constructors.  The variadic one, where arguments
are forwarded to construct the underlying begin iterator.  The end
iterator is constructed through default construction.  This is a
generalization of what we have today.

There is another constructor which receives already constructed begin
and end iterators, useful if the end iterator can't be obtained by
default-construction.  Or, if you wanted to make a range that does not
end at the end of the container, you could pass any iterator as the
"end".

This generalization allows removing some "range" classes, like
all_inferiors_range.  These classes existed only to pass some arguments
when constructing the begin iterator.  With iterator_range, those same
arguments are passed to the iterator_range constructed and then
forwarded to the constructed begin iterator.

There is a small functional difference in how iterator_range works
compared to next_adapter.  next_adapter stored the pointer it received
as argument and constructeur an iterator in the `begin` method.
iterator_range constructs the begin iterator and stores it as a member.
Its `begin` method returns a copy of that iterator.

With just iterator_range, uses of next_adapter<foo> would be replaced
with:

  using foo_iterator = next_iterator<foo>;
  using foo_range = iterator_range<foo_iterator>;

However, I added a `next_range` wrapper as a direct replacement for
next_adapter<foo>.  IMO, next_range is a slightly better name than
next_adapter.

The rest of the changes are applications of this new class.

gdbsupport/ChangeLog:

	* next-iterator.h (class next_adapter): Remove.
	* iterator-range.h: New.

gdb/ChangeLog:

	* breakpoint.h (bp_locations_range): Remove.
	(bp_location_range): New.
	(struct breakpoint) <locations>: Adjust type.
	(breakpoint_range): Use iterator_range.
	(tracepoint_range): Use iterator_range.
	* breakpoint.c (breakpoint::locations): Adjust return type.
	* gdb_bfd.h (gdb_bfd_section_range): Use iterator_range.
	* gdbthread.h (all_threads_safe): Pass argument to
	all_threads_safe_range.
	* inferior-iter.h (all_inferiors_range): Use iterator_range.
	(all_inferiors_safe_range): Use iterator_range.
	(all_non_exited_inferiors_range): Use iterator_range.
	* inferior.h (all_inferiors, all_non_exited_inferiors): Pass
	inferior_list as argument.
	* objfiles.h (struct objfile) <compunits_range>: Remove.
	<compunits>: Return compunit_symtab_range.
	* progspace.h (unwrapping_objfile_iterator)
	<unwrapping_objfile_iterator>: Take parameter by value.
	(unwrapping_objfile_range): Use iterator_range.
	(struct program_space) <objfiles_range>: Define with "using".
	<objfiles>: Adjust.
	<objfiles_safe_range>: Define with "using".
	<objfiles_safe>: Adjust.
	<solibs>: Return so_list_range, define here.
	* progspace.c (program_space::solibs): Remove.
	* psymtab.h (class psymtab_storage) <partial_symtab_iterator>:
	New.
	<partial_symtab_range>: Use iterator_range.
	* solist.h (so_list_range): New.
	* symtab.h (compunit_symtab_range):
	New.
	(symtab_range): New.
	(compunit_filetabs): Change to a function.
	* thread-iter.h (inf_threads_range,
	inf_non_exited_threads_range, safe_inf_threads_range,
	all_threads_safe_range): Use iterator_range.
	* top.h (ui_range): New.
	(all_uis): Use ui_range.

Change-Id: Ib7a9d2a3547f45f01aa1c6b24536ba159db9b854

2 files changed, 65 insertions, 27 deletions

diff --git a/gdbsupport/iterator-range.h b/gdbsupport/iterator-range.h
new file mode 100644
index 0000000..2a718e6
--- /dev/null
+++ b/gdbsupport/iterator-range.h
@@ -0,0 +1,60 @@
+/* A range adapter that wraps begin / end iterators.
+   Copyright (C) 2021 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#ifndef GDBSUPPORT_ITERATOR_RANGE_H
+#define GDBSUPPORT_ITERATOR_RANGE_H
+
+/* A wrapper that allows using ranged for-loops on a range described by two
+   iterators.  */
+
+template <typename IteratorType>
+struct iterator_range
+{
+  using iterator = IteratorType;
+
+  /* Create an iterator_range using BEGIN as the begin iterator.
+
+     Assume that the end iterator can be default-constructed.  */
+  template <typename... Args>
+  iterator_range (Args &&...args)
+    : m_begin (std::forward<Args> (args)...)
+  {}
+
+  /* Create an iterator range using explicit BEGIN and END iterators.  */
+  template <typename... Args>
+  iterator_range (IteratorType begin, IteratorType end)
+    : m_begin (std::move (begin)), m_end (std::move (end))
+  {}
+
+  /* Need these as the variadic constructor would be a better match
+     otherwise.  */
+  iterator_range (iterator_range &) = default;
+  iterator_range (const iterator_range &) = default;
+  iterator_range (iterator_range &&) = default;
+
+  IteratorType begin () const
+  { return m_begin; }
+
+  IteratorType end () const
+  { return m_end; }
+
+private:
+  IteratorType m_begin, m_end;
+};
+
+#endif /* GDBSUPPORT_ITERATOR_RANGE_H */
diff --git a/gdbsupport/next-iterator.h b/gdbsupport/next-iterator.h
index 5017524..72b241e 100644
--- a/gdbsupport/next-iterator.h
+++ b/gdbsupport/next-iterator.h
@@ -19,6 +19,8 @@
 #ifndef COMMON_NEXT_ITERATOR_H
 #define COMMON_NEXT_ITERATOR_H
 
+#include "gdbsupport/iterator-range.h"
+
 /* An iterator that uses the 'next' field of a type to iterate.  This
    can be used with various GDB types that are stored as linked
    lists.  */
@@ -70,33 +72,9 @@ private:
   T *m_item;
 };
 
-/* A range adapter that allows iterating over a linked list.  */
-
-template<typename T, typename Iterator = next_iterator<T>>
-class next_adapter
-{
-public:
-
-  explicit next_adapter (T *item)
-    : m_item (item)
-  {
-  }
-
-  using iterator = Iterator;
-
-  iterator begin () const
-  {
-    return iterator (m_item);
-  }
-
-  iterator end () const
-  {
-    return iterator ();
-  }
+/* A convenience wrapper to make a range type around a next_iterator.  */
 
-private:
-
-  T *m_item;
-};
+template <typename T>
+using next_range = iterator_range<next_iterator<T>>;
 
 #endif /* COMMON_NEXT_ITERATOR_H */