[PATCH 0/5] Handle pointers and references correctly in DAP

[PATCH 0/5] Handle pointers and references correctly in DAP

[Tom Tromey]

This series started off as a simple implementation of a no-op
pretty-printer to handle pointers and references in DAP.

However, this regressed a test, and I realized that the new
is-array-like and is-string-like code should be generalized to work
with any language.

This is done by associating a language with each type, which meant
touching every debug reader, plus a few minor preliminary cleanups.

Regression tested on x86-64 Fedora 36.

---
Tom Tromey (5):
      Pass a type allocator to init_fixed_point_type
      Regularize some DWARF type initialization
      Add is_array_like and to_array to language_defn
      Give a language to a type
      Handle pointers and references correctly in DAP

 gdb/ada-lang.c                   |  13 +++++
 gdb/coffread.c                   |   4 +-
 gdb/ctfread.c                    |  17 ++++---
 gdb/dwarf2/read.c                |  89 +++++++++++++++++----------------
 gdb/gdbtypes.c                   |  31 ++++++------
 gdb/gdbtypes.h                   |  37 ++++++++------
 gdb/language.h                   |  11 +++++
 gdb/mdebugread.c                 |   9 ++--
 gdb/python/lib/gdb/printing.py   |  16 ++++++
 gdb/python/py-type.c             |  13 ++---
 gdb/rust-lang.h                  |  10 ++++
 gdb/stabsread.c                  |  20 ++++----
 gdb/testsuite/gdb.dap/ptrref.cc  |  34 +++++++++++++
 gdb/testsuite/gdb.dap/ptrref.exp | 103 +++++++++++++++++++++++++++++++++++++++
 gdb/valarith.c                   |   6 +--
 15 files changed, 303 insertions(+), 110 deletions(-)
---
base-commit: a006bc9c37e95b4afaf85715cc54fe57b3300ccd
change-id: 20230905-dap-30821-pointers-6b62c5cb8a9f

Best regards,
-- 
Tom Tromey <tromey@adacore.com>

[PATCH 1/5] Pass a type allocator to init_fixed_point_type

[Tom Tromey]

init_fixed_point_type currently takes an objfile and creates its own
type allocator.  However, for a later patch it is more convenient if
this function accepts a type allocator.  This patch makes this change.
---
 gdb/dwarf2/read.c | 4 ++--
 gdb/gdbtypes.c    | 4 ++--
 gdb/gdbtypes.h    | 2 +-
 3 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
index 98bedbc5d49..2335bbe0aba 100644
--- a/gdb/dwarf2/read.c
+++ b/gdb/dwarf2/read.c
@@ -15380,11 +15380,11 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu)
 	}
 	break;
       case DW_ATE_signed_fixed:
-	type = init_fixed_point_type (objfile, bits, 0, name);
+	type = init_fixed_point_type (alloc, bits, 0, name);
 	finish_fixed_point_type (type, gnat_encoding_suffix, die, cu);
 	break;
       case DW_ATE_unsigned_fixed:
-	type = init_fixed_point_type (objfile, bits, 1, name);
+	type = init_fixed_point_type (alloc, bits, 1, name);
 	finish_fixed_point_type (type, gnat_encoding_suffix, die, cu);
 	break;
 
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index c9322108299..667b4e34a24 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -3498,12 +3498,12 @@ init_pointer_type (type_allocator &alloc,
    NAME is the type name.  */
 
 struct type *
-init_fixed_point_type (struct objfile *objfile,
+init_fixed_point_type (type_allocator &alloc,
 		       int bit, int unsigned_p, const char *name)
 {
   struct type *t;
 
-  t = type_allocator (objfile).new_type (TYPE_CODE_FIXED_POINT, bit, name);
+  t = alloc.new_type (TYPE_CODE_FIXED_POINT, bit, name);
   if (unsigned_p)
     t->set_is_unsigned (true);
 
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index f667b10ec7d..df94e952c1f 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -2379,7 +2379,7 @@ extern struct type *init_pointer_type (type_allocator &alloc, int bit,
 				       const char *name,
 				       struct type *target_type);
 
-extern struct type *init_fixed_point_type (struct objfile *, int, int,
+extern struct type *init_fixed_point_type (type_allocator &, int, int,
 					   const char *);
 
 /* Helper functions to construct a struct or record type.  An

-- 
2.40.1

[PATCH 2/5] Regularize some DWARF type initialization

[Tom Tromey]

In one spot, it will be convenient for a subsequent patch if the CU is
passed to a type-creation helper function.  In another spot, remove
the redundant 'objfile' parameter to another such function.
---
 gdb/dwarf2/read.c | 24 +++++++++++++-----------
 1 file changed, 13 insertions(+), 11 deletions(-)

diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
index 2335bbe0aba..63a2a83f0a2 100644
--- a/gdb/dwarf2/read.c
+++ b/gdb/dwarf2/read.c
@@ -15090,9 +15090,10 @@ gnat_encoded_fixed_point_type_info (const char *name)
    it to guess the correct format if necessary.  */
 
 static struct type *
-dwarf2_init_float_type (struct objfile *objfile, int bits, const char *name,
+dwarf2_init_float_type (struct dwarf2_cu *cu, int bits, const char *name,
 			const char *name_hint, enum bfd_endian byte_order)
 {
+  struct objfile *objfile = cu->per_objfile->objfile;
   struct gdbarch *gdbarch = objfile->arch ();
   const struct floatformat **format;
   struct type *type;
@@ -15110,10 +15111,11 @@ dwarf2_init_float_type (struct objfile *objfile, int bits, const char *name,
 /* Allocate an integer type of size BITS and name NAME.  */
 
 static struct type *
-dwarf2_init_integer_type (struct dwarf2_cu *cu, struct objfile *objfile,
-			  int bits, int unsigned_p, const char *name)
+dwarf2_init_integer_type (struct dwarf2_cu *cu, int bits, int unsigned_p,
+			  const char *name)
 {
   struct type *type;
+  struct objfile *objfile = cu->per_objfile->objfile;
 
   /* Versions of Intel's C Compiler generate an integer type called "void"
      instead of using DW_TAG_unspecified_type.  This has been seen on
@@ -15167,10 +15169,10 @@ has_zero_over_zero_small_attribute (struct die_info *die,
    component.  */
 static struct type *
 dwarf2_init_complex_target_type (struct dwarf2_cu *cu,
-				 struct objfile *objfile,
 				 int bits, const char *name_hint,
 				 enum bfd_endian byte_order)
 {
+  struct objfile *objfile = cu->per_objfile->objfile;
   gdbarch *gdbarch = objfile->arch ();
   struct type *tt = nullptr;
 
@@ -15218,7 +15220,7 @@ dwarf2_init_complex_target_type (struct dwarf2_cu *cu,
     tt = nullptr;
 
   const char *name = (tt == nullptr) ? nullptr : tt->name ();
-  return dwarf2_init_float_type (objfile, bits, name, name_hint, byte_order);
+  return dwarf2_init_float_type (cu, bits, name, name_hint, byte_order);
 }
 
 /* Find a representation of a given base type and install
@@ -15321,7 +15323,7 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu)
 	type = init_boolean_type (alloc, bits, 1, name);
 	break;
       case DW_ATE_complex_float:
-	type = dwarf2_init_complex_target_type (cu, objfile, bits / 2, name,
+	type = dwarf2_init_complex_target_type (cu, bits / 2, name,
 						byte_order);
 	if (type->code () == TYPE_CODE_ERROR)
 	  {
@@ -15341,10 +15343,10 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu)
 	type = init_decfloat_type (alloc, bits, name);
 	break;
       case DW_ATE_float:
-	type = dwarf2_init_float_type (objfile, bits, name, name, byte_order);
+	type = dwarf2_init_float_type (cu, bits, name, name, byte_order);
 	break;
       case DW_ATE_signed:
-	type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
+	type = dwarf2_init_integer_type (cu, bits, 0, name);
 	break;
       case DW_ATE_unsigned:
 	if (cu->lang () == language_fortran
@@ -15352,7 +15354,7 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu)
 	    && startswith (name, "character("))
 	  type = init_character_type (alloc, bits, 1, name);
 	else
-	  type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
+	  type = dwarf2_init_integer_type (cu, bits, 1, name);
 	break;
       case DW_ATE_signed_char:
 	if (cu->lang () == language_ada
@@ -15361,7 +15363,7 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu)
 	    || cu->lang () == language_fortran)
 	  type = init_character_type (alloc, bits, 0, name);
 	else
-	  type = dwarf2_init_integer_type (cu, objfile, bits, 0, name);
+	  type = dwarf2_init_integer_type (cu, bits, 0, name);
 	break;
       case DW_ATE_unsigned_char:
 	if (cu->lang () == language_ada
@@ -15371,7 +15373,7 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu)
 	    || cu->lang () == language_rust)
 	  type = init_character_type (alloc, bits, 1, name);
 	else
-	  type = dwarf2_init_integer_type (cu, objfile, bits, 1, name);
+	  type = dwarf2_init_integer_type (cu, bits, 1, name);
 	break;
       case DW_ATE_UTF:
 	{

-- 
2.40.1

[PATCH 3/5] Add is_array_like and to_array to language_defn

[Tom Tromey]

This adds new is_array_like and to_array methods to language_defn.
This will be used in a subsequent patch that generalizes the new
Python array- and string-handling code.
---
 gdb/ada-lang.c  | 13 +++++++++++++
 gdb/language.h  | 11 +++++++++++
 gdb/rust-lang.h | 10 ++++++++++
 3 files changed, 34 insertions(+)

diff --git a/gdb/ada-lang.c b/gdb/ada-lang.c
index c0cc512bfa3..b03ed53d11c 100644
--- a/gdb/ada-lang.c
+++ b/gdb/ada-lang.c
@@ -13810,6 +13810,19 @@ class ada_language : public language_defn
 
   /* See language.h.  */
 
+  bool is_array_like (struct type *type) const override
+  {
+    return (ada_is_constrained_packed_array_type (type)
+	    || ada_is_array_descriptor_type (type));
+  }
+
+  /* See language.h.  */
+
+  struct value *to_array (struct value *val) const override
+  { return ada_coerce_to_simple_array (val); }
+
+  /* See language.h.  */
+
   const char *struct_too_deep_ellipsis () const override
   { return "(...)"; }
 
diff --git a/gdb/language.h b/gdb/language.h
index 9fd2fb6f387..6ee8f6160e1 100644
--- a/gdb/language.h
+++ b/gdb/language.h
@@ -568,6 +568,17 @@ struct language_defn
   /* Return true if TYPE is a string type.  */
   virtual bool is_string_type_p (struct type *type) const;
 
+  /* Return true if TYPE is array-like.  */
+  virtual bool is_array_like (struct type *type) const
+  { return false; }
+
+  /* Underlying implementation of value_to_array.  Return a value of
+     array type that corresponds to VAL.  The caller must ensure that
+     is_array_like is true for VAL's type.  Return nullptr if the type
+     cannot be handled.  */
+  virtual struct value *to_array (struct value *val) const
+  { return nullptr; }
+
   /* Return a string that is used by the 'set print max-depth' setting.
      When GDB replaces a struct or union (during value printing) that is
      "too deep" this string is displayed instead.  The default value here
diff --git a/gdb/rust-lang.h b/gdb/rust-lang.h
index 2c7ccb93bcf..ce1dff211b6 100644
--- a/gdb/rust-lang.h
+++ b/gdb/rust-lang.h
@@ -196,6 +196,16 @@ class rust_language : public language_defn
 
   /* See language.h.  */
 
+  bool is_array_like (struct type *type) const override
+  { return rust_slice_type_p (type); }
+
+  /* See language.h.  */
+
+  struct value *to_array (struct value *val) const override
+  { return rust_slice_to_array (val); }
+
+  /* See language.h.  */
+
   bool range_checking_on_by_default () const override
   { return true; }
 

-- 
2.40.1

[PATCH 4/5] Give a language to a type

[Tom Tromey]

This changes main_type to hold a language, and updates the debug
readers to set this field.  This is done by adding the language to the
type-allocator object.

Note that the non-DWARF readers are changed on a "best effort" basis.

This patch also reimplements type::is_array_like to use the type's
language, and it adds a new type::is_string_like as well.  This in
turn lets us change the Python implementation of these methods to
simply defer to the type.
---
 gdb/coffread.c       |  4 ++--
 gdb/ctfread.c        | 17 ++++++++-------
 gdb/dwarf2/read.c    | 61 +++++++++++++++++++++++++---------------------------
 gdb/gdbtypes.c       | 27 ++++++++++++-----------
 gdb/gdbtypes.h       | 35 +++++++++++++++++++-----------
 gdb/mdebugread.c     |  9 ++++----
 gdb/python/py-type.c | 13 ++++-------
 gdb/stabsread.c      | 20 +++++++++--------
 gdb/valarith.c       |  6 ++----
 9 files changed, 98 insertions(+), 94 deletions(-)

diff --git a/gdb/coffread.c b/gdb/coffread.c
index e432693600e..fe905e73964 100644
--- a/gdb/coffread.c
+++ b/gdb/coffread.c
@@ -354,7 +354,7 @@ coff_alloc_type (int index)
      We will fill it in later if we find out how.  */
   if (type == NULL)
     {
-      type = type_allocator (coffread_objfile).new_type ();
+      type = type_allocator (coffread_objfile, language_c).new_type ();
       *type_addr = type;
     }
   return type;
@@ -1763,7 +1763,7 @@ decode_type (struct coff_symbol *cs, unsigned int c_type,
 
 	  base_type = decode_type (cs, new_c_type, aux, objfile);
 	  index_type = builtin_type (objfile)->builtin_int;
-	  type_allocator alloc (objfile);
+	  type_allocator alloc (objfile, language_c);
 	  range_type
 	    = create_static_range_type (alloc, index_type, 0, n - 1);
 	  type = create_array_type (alloc, base_type, range_type);
diff --git a/gdb/ctfread.c b/gdb/ctfread.c
index c04b043d6d3..c74ec044c18 100644
--- a/gdb/ctfread.c
+++ b/gdb/ctfread.c
@@ -370,7 +370,7 @@ ctf_init_float_type (struct objfile *objfile,
   const struct floatformat **format;
   struct type *type;
 
-  type_allocator alloc (objfile);
+  type_allocator alloc (objfile, language_c);
   format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
   if (format != nullptr)
     type = init_float_type (alloc, bits, name, format);
@@ -553,7 +553,7 @@ read_base_type (struct ctf_context *ccp, ctf_id_t tid)
 		   ctf_errmsg (ctf_errno (fp)));
     }
 
-  type_allocator alloc (of);
+  type_allocator alloc (of, language_c);
   kind = ctf_type_kind (fp, tid);
   if (kind == CTF_K_INTEGER)
     {
@@ -629,7 +629,7 @@ read_structure_type (struct ctf_context *ccp, ctf_id_t tid)
   struct type *type;
   uint32_t kind;
 
-  type = type_allocator (of).new_type ();
+  type = type_allocator (of, language_c).new_type ();
 
   const char *name = ctf_type_name_raw (fp, tid);
   if (name != nullptr && strlen (name) != 0)
@@ -688,7 +688,7 @@ read_func_kind_type (struct ctf_context *ccp, ctf_id_t tid)
   ctf_funcinfo_t cfi;
   uint32_t argc;
 
-  type = type_allocator (of).new_type ();
+  type = type_allocator (of, language_c).new_type ();
 
   type->set_code (TYPE_CODE_FUNC);
   if (ctf_func_type_info (fp, tid, &cfi) < 0)
@@ -739,7 +739,7 @@ read_enum_type (struct ctf_context *ccp, ctf_id_t tid)
   ctf_dict_t *fp = ccp->fp;
   struct type *type;
 
-  type = type_allocator (of).new_type ();
+  type = type_allocator (of, language_c).new_type ();
 
   const char *name = ctf_type_name_raw (fp, tid);
   if (name != nullptr && strlen (name) != 0)
@@ -828,7 +828,7 @@ read_array_type (struct ctf_context *ccp, ctf_id_t tid)
   if (idx_type == nullptr)
     idx_type = builtin_type (objfile)->builtin_int;
 
-  type_allocator alloc (objfile);
+  type_allocator alloc (objfile, language_c);
   range_type = create_static_range_type (alloc, idx_type, 0, ar.ctr_nelems - 1);
   type = create_array_type (alloc, element_type, range_type);
   if (ar.ctr_nelems <= 1)	/* Check if undefined upper bound.  */
@@ -928,7 +928,8 @@ read_typedef_type (struct ctf_context *ccp, ctf_id_t tid,
   struct type *this_type, *target_type;
 
   char *aname = obstack_strdup (&objfile->objfile_obstack, name);
-  this_type = type_allocator (objfile).new_type (TYPE_CODE_TYPEDEF, 0, aname);
+  this_type = type_allocator (objfile, language_c).new_type (TYPE_CODE_TYPEDEF,
+							     0, aname);
   set_tid_type (objfile, tid, this_type);
   target_type = fetch_tid_type (ccp, btid);
   if (target_type != this_type)
@@ -976,7 +977,7 @@ read_forward_type (struct ctf_context *ccp, ctf_id_t tid)
   struct type *type;
   uint32_t kind;
 
-  type = type_allocator (of).new_type ();
+  type = type_allocator (of, language_c).new_type ();
 
   const char *name = ctf_type_name_raw (fp, tid);
   if (name != nullptr && strlen (name) != 0)
diff --git a/gdb/dwarf2/read.c b/gdb/dwarf2/read.c
index 63a2a83f0a2..99a31407a0a 100644
--- a/gdb/dwarf2/read.c
+++ b/gdb/dwarf2/read.c
@@ -5890,8 +5890,8 @@ fixup_go_packaging (struct dwarf2_cu *cu)
       struct objfile *objfile = cu->per_objfile->objfile;
       const char *saved_package_name = objfile->intern (package_name.get ());
       struct type *type
-	= type_allocator (objfile).new_type (TYPE_CODE_MODULE, 0,
-					     saved_package_name);
+	= type_allocator (objfile, cu->lang ()).new_type (TYPE_CODE_MODULE, 0,
+							  saved_package_name);
       struct symbol *sym;
 
       sym = new (&objfile->objfile_obstack) symbol;
@@ -6077,8 +6077,8 @@ quirk_rust_enum (struct type *type, struct objfile *objfile)
 	= rust_fully_qualify (&objfile->objfile_obstack, type->name (),
 			      name);
       struct type *dataless_type
-	= type_allocator (objfile).new_type (TYPE_CODE_VOID, 0,
-					     dataless_name);
+	= type_allocator (type).new_type (TYPE_CODE_VOID, 0,
+					  dataless_name);
       type->field (2).set_type (dataless_type);
       /* NAME points into the original discriminant name, which
 	 already has the correct lifetime.  */
@@ -12215,7 +12215,7 @@ dwarf2_add_member_fn (struct field_info *fip, struct die_info *die,
       fnp->physname = physname ? physname : "";
     }
 
-  fnp->type = type_allocator (objfile).new_type ();
+  fnp->type = type_allocator (objfile, cu->lang ()).new_type ();
   this_type = read_type_die (die, cu);
   if (this_type && this_type->code () == TYPE_CODE_FUNC)
     {
@@ -12446,7 +12446,7 @@ quirk_gcc_member_function_pointer (struct type *type, struct objfile *objfile)
     return;
 
   self_type = pfn_type->field (0).type ()->target_type ();
-  new_type = type_allocator (objfile).new_type ();
+  new_type = type_allocator (type).new_type ();
   smash_to_method_type (new_type, self_type, pfn_type->target_type (),
 			pfn_type->fields (), pfn_type->num_fields (),
 			pfn_type->has_varargs ());
@@ -12680,15 +12680,8 @@ read_structure_type (struct die_info *die, struct dwarf2_cu *cu)
       return set_die_type (die, type, cu);
     }
 
-  type = type_allocator (objfile).new_type ();
-  if (cu->lang () == language_rust)
-    {
-      /* This is currently only needed for types that might be
-	 slices.  */
-      INIT_RUST_SPECIFIC (type);
-    }
-  else
-    INIT_CPLUS_SPECIFIC (type);
+  type = type_allocator (objfile, cu->lang ()).new_type ();
+  INIT_CPLUS_SPECIFIC (type);
 
   name = dwarf2_name (die, cu);
   if (name != NULL)
@@ -13291,7 +13284,7 @@ read_enumeration_type (struct die_info *die, struct dwarf2_cu *cu)
       return set_die_type (die, type, cu);
     }
 
-  type = type_allocator (objfile).new_type ();
+  type = type_allocator (objfile, cu->lang ()).new_type ();
 
   type->set_code (TYPE_CODE_ENUM);
   name = dwarf2_full_name (NULL, die, cu);
@@ -13621,7 +13614,7 @@ quirk_ada_thick_pointer (struct die_info *die, struct dwarf2_cu *cu,
       range_fields[i + 1].set_name (objfile->intern (name));
     }
 
-  type_allocator alloc (objfile);
+  type_allocator alloc (objfile, cu->lang ());
   struct type *bounds = alloc.new_type ();
   bounds->set_code (TYPE_CODE_STRUCT);
 
@@ -13645,7 +13638,7 @@ quirk_ada_thick_pointer (struct die_info *die, struct dwarf2_cu *cu,
       iter = iter->target_type ();
     }
 
-  struct type *result = type_allocator (objfile).new_type ();
+  struct type *result = type_allocator (objfile, cu->lang ()).new_type ();
   result->set_code (TYPE_CODE_STRUCT);
 
   result->alloc_fields (2);
@@ -13722,7 +13715,7 @@ read_array_type (struct die_info *die, struct dwarf2_cu *cu)
   if (die->child == NULL)
     {
       index_type = builtin_type (objfile)->builtin_int;
-      type_allocator alloc (objfile);
+      type_allocator alloc (objfile, cu->lang ());
       range_type = create_static_range_type (alloc, index_type, 0, -1);
       type = create_array_type_with_stride (alloc, element_type, range_type,
 					    byte_stride_prop, bit_stride);
@@ -13761,7 +13754,7 @@ read_array_type (struct die_info *die, struct dwarf2_cu *cu)
 
   type = element_type;
 
-  type_allocator alloc (cu->per_objfile->objfile);
+  type_allocator alloc (cu->per_objfile->objfile, cu->lang ());
   if (read_array_order (die, cu) == DW_ORD_col_major)
     {
       int i = 0;
@@ -13891,7 +13884,7 @@ read_set_type (struct die_info *die, struct dwarf2_cu *cu)
   if (set_type)
     return set_type;
 
-  type_allocator alloc (cu->per_objfile->objfile);
+  type_allocator alloc (cu->per_objfile->objfile, cu->lang ());
   set_type = create_set_type (alloc, domain_type);
 
   attr = dwarf2_attr (die, DW_AT_byte_size, cu);
@@ -14111,7 +14104,8 @@ read_namespace_type (struct die_info *die, struct dwarf2_cu *cu)
 			    previous_prefix, name, 0, cu);
 
   /* Create the type.  */
-  type = type_allocator (objfile).new_type (TYPE_CODE_NAMESPACE, 0, name);
+  type = type_allocator (objfile, cu->lang ()).new_type (TYPE_CODE_NAMESPACE,
+							 0, name);
 
   return set_die_type (die, type, cu);
 }
@@ -14173,7 +14167,8 @@ read_module_type (struct die_info *die, struct dwarf2_cu *cu)
   struct type *type;
 
   module_name = dwarf2_name (die, cu);
-  type = type_allocator (objfile).new_type (TYPE_CODE_MODULE, 0, module_name);
+  type = type_allocator (objfile, cu->lang ()).new_type (TYPE_CODE_MODULE,
+							 0, module_name);
 
   return set_die_type (die, type, cu);
 }
@@ -14328,7 +14323,7 @@ read_tag_ptr_to_member_type (struct die_info *die, struct dwarf2_cu *cu)
   else if (check_typedef (to_type)->code () == TYPE_CODE_FUNC)
     {
       struct type *new_type
-	= type_allocator (cu->per_objfile->objfile).new_type ();
+	= type_allocator (cu->per_objfile->objfile, cu->lang ()).new_type ();
 
       smash_to_method_type (new_type, domain, to_type->target_type (),
 			    to_type->fields (), to_type->num_fields (),
@@ -14566,7 +14561,7 @@ read_tag_string_type (struct die_info *die, struct dwarf2_cu *cu)
     }
 
   index_type = builtin_type (objfile)->builtin_int;
-  type_allocator alloc (objfile);
+  type_allocator alloc (objfile, cu->lang ());
   if (length_is_constant)
     range_type = create_static_range_type (alloc, index_type, 1, length);
   else
@@ -14787,7 +14782,8 @@ read_typedef (struct die_info *die, struct dwarf2_cu *cu)
       return this_type;
     }
 
-  this_type = type_allocator (objfile).new_type (TYPE_CODE_TYPEDEF, 0, name);
+  type_allocator alloc (objfile, cu->lang ());
+  this_type = alloc.new_type (TYPE_CODE_TYPEDEF, 0, name);
   this_type->set_target_is_stub (true);
   set_die_type (die, this_type, cu);
   if (target_type != this_type)
@@ -15098,7 +15094,7 @@ dwarf2_init_float_type (struct dwarf2_cu *cu, int bits, const char *name,
   const struct floatformat **format;
   struct type *type;
 
-  type_allocator alloc (objfile);
+  type_allocator alloc (objfile, cu->lang ());
   format = gdbarch_floatformat_for_type (gdbarch, name_hint, bits);
   if (format)
     type = init_float_type (alloc, bits, name, format, byte_order);
@@ -15125,7 +15121,7 @@ dwarf2_init_integer_type (struct dwarf2_cu *cu, int bits, int unsigned_p,
     type = builtin_type (objfile)->builtin_void;
   else
     {
-      type_allocator alloc (objfile);
+      type_allocator alloc (objfile, cu->lang ());
       type = init_integer_type (alloc, bits, unsigned_p, name);
     }
 
@@ -15311,7 +15307,7 @@ read_base_type (struct die_info *die, struct dwarf2_cu *cu)
 	}
     }
 
-  type_allocator alloc (objfile);
+  type_allocator alloc (objfile, cu->lang ());
   switch (encoding)
     {
       case DW_ATE_address:
@@ -15800,7 +15796,7 @@ read_subrange_type (struct die_info *die, struct dwarf2_cu *cu)
 	}
     }
 
-  type_allocator alloc (cu->per_objfile->objfile);
+  type_allocator alloc (cu->per_objfile->objfile, cu->lang ());
   if (attr_byte_stride != nullptr
       || attr_bit_stride != nullptr)
     {
@@ -15845,7 +15841,7 @@ read_unspecified_type (struct die_info *die, struct dwarf2_cu *cu)
 {
   struct type *type;
 
-  type = (type_allocator (cu->per_objfile->objfile)
+  type = (type_allocator (cu->per_objfile->objfile, cu->lang ())
 	  .new_type (TYPE_CODE_VOID, 0, nullptr));
   type->set_name (dwarf2_name (die, cu));
 
@@ -19706,7 +19702,8 @@ build_error_marker_type (struct dwarf2_cu *cu, struct die_info *die)
 		     sect_offset_str (die->sect_off));
   saved = obstack_strdup (&objfile->objfile_obstack, message);
 
-  return type_allocator (objfile).new_type (TYPE_CODE_ERROR, 0, saved);
+  return type_allocator (objfile, cu->lang ()).new_type (TYPE_CODE_ERROR,
+							 0, saved);
 }
 
 /* Look up the type of DIE in CU using its type attribute ATTR.
diff --git a/gdb/gdbtypes.c b/gdb/gdbtypes.c
index 667b4e34a24..7011fddd695 100644
--- a/gdb/gdbtypes.c
+++ b/gdb/gdbtypes.c
@@ -217,6 +217,7 @@ type_allocator::new_type ()
   /* Alloc the structure and start off with all fields zeroed.  */
   struct type *type = OBSTACK_ZALLOC (obstack, struct type);
   TYPE_MAIN_TYPE (type) = OBSTACK_ZALLOC (obstack, struct main_type);
+  TYPE_MAIN_TYPE (type)->m_lang = m_lang;
 
   if (m_is_objfile)
     {
@@ -5385,10 +5386,6 @@ recursive_dump_type (struct type *type, int spaces)
       print_gnat_stuff (type, spaces);
       break;
 
-    case TYPE_SPECIFIC_RUST_STUFF:
-      gdb_printf ("%*srust\n", spaces, "");
-      break;
-
     case TYPE_SPECIFIC_FLOATFORMAT:
       gdb_printf ("%*sfloatformat ", spaces, "");
       if (TYPE_FLOATFORMAT (type) == NULL
@@ -5629,9 +5626,6 @@ copy_type_recursive (struct type *type, htab_t copied_types)
     case TYPE_SPECIFIC_GNAT_STUFF:
       INIT_GNAT_SPECIFIC (new_type);
       break;
-    case TYPE_SPECIFIC_RUST_STUFF:
-      INIT_RUST_SPECIFIC (new_type);
-      break;
     case TYPE_SPECIFIC_SELF_TYPE:
       set_type_self_type (new_type,
 			  copy_type_recursive (TYPE_SELF_TYPE (type),
@@ -5948,17 +5942,24 @@ type::copy_fields (std::vector<struct field> &src)
   memcpy (this->fields (), src.data (), size);
 }
 
+/* See gdbtypes.h.  */
+
+bool
+type::is_string_like ()
+{
+  const language_defn *defn = language_def (this->language ());
+  return defn->is_string_type_p (this);
+}
+
+/* See gdbtypes.h.  */
+
 bool
 type::is_array_like ()
 {
   if (code () == TYPE_CODE_ARRAY)
     return true;
-  if (HAVE_GNAT_AUX_INFO (this))
-    return (ada_is_constrained_packed_array_type (this)
-	    || ada_is_array_descriptor_type (this));
-  if (HAVE_RUST_SPECIFIC (this))
-    return rust_slice_type_p (this);
-  return false;
+  const language_defn *defn = language_def (this->language ());
+  return defn->is_array_like (this);
 }
 
 \f
diff --git a/gdb/gdbtypes.h b/gdb/gdbtypes.h
index df94e952c1f..505c8ba12b5 100644
--- a/gdb/gdbtypes.h
+++ b/gdb/gdbtypes.h
@@ -501,7 +501,6 @@ enum type_specific_kind
   TYPE_SPECIFIC_NONE,
   TYPE_SPECIFIC_CPLUS_STUFF,
   TYPE_SPECIFIC_GNAT_STUFF,
-  TYPE_SPECIFIC_RUST_STUFF,
   TYPE_SPECIFIC_FLOATFORMAT,
   /* Note: This is used by TYPE_CODE_FUNC and TYPE_CODE_METHOD.  */
   TYPE_SPECIFIC_FUNC,
@@ -857,7 +856,11 @@ struct main_type
   /* * A discriminant telling us which field of the type_specific
      union is being used for this type, if any.  */
 
-  ENUM_BITFIELD(type_specific_kind) type_specific_field : 4;
+  ENUM_BITFIELD(type_specific_kind) type_specific_field : 3;
+
+  /* The language for this type.  */
+
+  ENUM_BITFIELD(language) m_lang : LANGUAGE_BITS;
 
   /* * Number of fields described for this type.  This field appears
      at this location because it packs nicely here.  */
@@ -1430,11 +1433,19 @@ struct type
     return this->code () == TYPE_CODE_PTR || TYPE_IS_REFERENCE (this);
   }
 
+  /* Return true if this type is "string-like", according to its
+     defining language.  */
+  bool is_string_like ();
+
   /* Return true if this type is "array-like".  This includes arrays,
      but also some forms of structure type that are recognized as
      representations of arrays by the type's language.  */
   bool is_array_like ();
 
+  /* Return the language that this type came from.  */
+  enum language language () const
+  { return main_type->m_lang; }
+
   /* * Type that is a pointer to this type.
      NULL if no such pointer-to type is known yet.
      The debugger may add the address of such a type
@@ -1839,14 +1850,6 @@ extern void allocate_gnat_aux_type (struct type *);
     || (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_NONE	\
 	&& (type)->is_fixed_instance ()))
 
-/* Currently there isn't any associated data -- this is just a
-   marker.  */
-#define INIT_RUST_SPECIFIC(type) \
-  TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_RUST_STUFF
-
-#define HAVE_RUST_SPECIFIC(type) \
-  (TYPE_SPECIFIC_FIELD (type) == TYPE_SPECIFIC_RUST_STUFF)
-
 #define INIT_FUNC_SPECIFIC(type)					       \
   (TYPE_SPECIFIC_FIELD (type) = TYPE_SPECIFIC_FUNC,			       \
    TYPE_MAIN_TYPE (type)->type_specific.func_stuff = (struct func_type *)      \
@@ -2242,14 +2245,16 @@ class type_allocator
 public:
 
   /* Create new types on OBJFILE.  */
-  explicit type_allocator (objfile *objfile)
-    : m_is_objfile (true)
+  type_allocator (objfile *objfile, enum language lang)
+    : m_is_objfile (true),
+      m_lang (lang)
   {
     m_data.objfile = objfile;
   }
 
   /* Create new types on GDBARCH.  */
   explicit type_allocator (gdbarch *gdbarch)
+    : m_lang (language_minimal)
   {
     m_data.gdbarch = gdbarch;
   }
@@ -2269,6 +2274,7 @@ class type_allocator
      is passed, overwrite TYPE.  */
   explicit type_allocator (struct type *type,
 			   type_allocator_kind kind = SAME)
+    : m_lang (type->language ())
   {
     if (kind == SAME)
       {
@@ -2289,7 +2295,8 @@ class type_allocator
 
   /* Create new types on the same obstack as TYPE.  */
   explicit type_allocator (const struct type *type)
-    : m_is_objfile (type->is_objfile_owned ())
+    : m_is_objfile (type->is_objfile_owned ()),
+      m_lang (type->language ())
   {
     if (type->is_objfile_owned ())
       m_data.objfile = type->objfile_owner ();
@@ -2326,6 +2333,8 @@ class type_allocator
   /* True if this allocator uses the type field above, indicating that
      the "allocation" should be done in-place.  */
   bool m_smash = false;
+  /* The language for types created by this allocator.  */
+  enum language m_lang;
 };
 
 /* Allocate a TYPE_CODE_INT type structure using ALLOC.  BIT is the
diff --git a/gdb/mdebugread.c b/gdb/mdebugread.c
index ea3e15be53b..47ac5419ec9 100644
--- a/gdb/mdebugread.c
+++ b/gdb/mdebugread.c
@@ -1381,7 +1381,7 @@ basic_type (int bt, struct objfile *objfile)
   if (map_bt[bt])
     return map_bt[bt];
 
-  type_allocator alloc (objfile);
+  type_allocator alloc (objfile, get_current_subfile ()->language);
 
   switch (bt)
     {
@@ -1570,7 +1570,7 @@ parse_type (int fd, union aux_ext *ax, unsigned int aux_index, int *bs,
 	}
     }
 
-  type_allocator alloc (mdebugread_objfile);
+  type_allocator alloc (mdebugread_objfile, get_current_subfile ()->language);
 
   /* Move on to next aux.  */
   ax++;
@@ -4290,7 +4290,7 @@ cross_ref (int fd, union aux_ext *ax, struct type **tpp,
       rf = rn->rfd;
     }
 
-  type_allocator alloc (mdebugread_objfile);
+  type_allocator alloc (mdebugread_objfile, get_current_subfile ()->language);
 
   /* mips cc uses a rf of -1 for opaque struct definitions.
      Set TYPE_STUB for these types so that check_typedef will
@@ -4753,7 +4753,8 @@ new_type (char *name)
 {
   struct type *t;
 
-  t = type_allocator (mdebugread_objfile).new_type ();
+  t = type_allocator (mdebugread_objfile,
+		      get_current_subfile ()->language).new_type ();
   t->set_name (name);
   INIT_CPLUS_SPECIFIC (t);
   return t;
diff --git a/gdb/python/py-type.c b/gdb/python/py-type.c
index 5e5f1750551..bfaa6d24d94 100644
--- a/gdb/python/py-type.c
+++ b/gdb/python/py-type.c
@@ -448,17 +448,19 @@ static PyObject *
 typy_is_array_like (PyObject *self, void *closure)
 {
   struct type *type = ((type_object *) self)->type;
+  bool result = false;
 
   try
     {
       type = check_typedef (type);
+      result = type->is_array_like ();
     }
   catch (const gdb_exception &except)
     {
       GDB_PY_HANDLE_EXCEPTION (except);
     }
 
-  if (type->is_array_like ())
+  if (result)
     Py_RETURN_TRUE;
   else
     Py_RETURN_FALSE;
@@ -475,14 +477,7 @@ typy_is_string_like (PyObject *self, void *closure)
   try
     {
       type = check_typedef (type);
-
-      const language_defn *lang = nullptr;
-      if (HAVE_GNAT_AUX_INFO (type))
-	lang = language_def (language_ada);
-      else if (HAVE_RUST_SPECIFIC (type))
-	lang = language_def (language_rust);
-      if (lang != nullptr)
-	result = lang->is_string_type_p (type);
+      result = type->is_string_like ();
     }
   catch (const gdb_exception &except)
     {
diff --git a/gdb/stabsread.c b/gdb/stabsread.c
index cc7efda61bf..473c11f3a85 100644
--- a/gdb/stabsread.c
+++ b/gdb/stabsread.c
@@ -346,7 +346,8 @@ dbx_alloc_type (int typenums[2], struct objfile *objfile)
 
   if (typenums[0] == -1)
     {
-      return type_allocator (objfile).new_type ();
+      return type_allocator (objfile,
+			     get_current_subfile ()->language).new_type ();
     }
 
   type_addr = dbx_lookup_type (typenums, objfile);
@@ -356,7 +357,8 @@ dbx_alloc_type (int typenums[2], struct objfile *objfile)
      We will fill it in later if we find out how.  */
   if (*type_addr == 0)
     {
-      *type_addr = type_allocator (objfile).new_type ();
+      *type_addr = type_allocator (objfile,
+				   get_current_subfile ()->language).new_type ();
     }
 
   return (*type_addr);
@@ -372,7 +374,7 @@ dbx_init_float_type (struct objfile *objfile, int bits)
   struct type *type;
 
   format = gdbarch_floatformat_for_type (gdbarch, NULL, bits);
-  type_allocator alloc (objfile);
+  type_allocator alloc (objfile, get_current_subfile ()->language);
   if (format)
     type = init_float_type (alloc, bits, NULL, format);
   else
@@ -877,7 +879,7 @@ define_symbol (CORE_ADDR valu, const char *string, int desc, int type,
 
 	    /* NULL terminate the string.  */
 	    string_local[ind] = 0;
-	    type_allocator alloc (objfile);
+	    type_allocator alloc (objfile, get_current_subfile ()->language);
 	    range_type
 	      = create_static_range_type (alloc,
 					  builtin_type (objfile)->builtin_int,
@@ -2014,7 +2016,7 @@ read_type (const char **pp, struct objfile *objfile)
     case 'S':			/* Set type */
       {
 	type1 = read_type (pp, objfile);
-	type_allocator alloc (objfile);
+	type_allocator alloc (objfile, get_current_subfile ()->language);
 	type = create_set_type (alloc, type1);
 	if (typenums[0] != -1)
 	  *dbx_lookup_type (typenums, objfile) = type;
@@ -2081,7 +2083,7 @@ rs6000_builtin_type (int typenum, struct objfile *objfile)
      TARGET_CHAR_BIT.  */
 #endif
 
-  type_allocator alloc (objfile);
+  type_allocator alloc (objfile, get_current_subfile ()->language);
   switch (-typenum)
     {
     case 1:
@@ -3536,7 +3538,7 @@ read_array_type (const char **pp, struct type *type,
       upper = -1;
     }
 
-  type_allocator alloc (objfile);
+  type_allocator alloc (objfile, get_current_subfile ()->language);
   range_type =
     create_static_range_type (alloc, index_type, lower, upper);
   type_allocator smash_alloc (type, type_allocator::SMASH);
@@ -3734,7 +3736,7 @@ read_sun_builtin_type (const char **pp, int typenums[2], struct objfile *objfile
   if (**pp == ';')
     ++(*pp);
 
-  type_allocator alloc (objfile);
+  type_allocator alloc (objfile, get_current_subfile ()->language);
   if (type_bits == 0)
     {
       struct type *type = alloc.new_type (TYPE_CODE_VOID,
@@ -4003,7 +4005,7 @@ read_range_type (const char **pp, int typenums[2], int type_size,
   if (n2bits == -1 || n3bits == -1)
     return error_type (pp, objfile);
 
-  type_allocator alloc (objfile);
+  type_allocator alloc (objfile, get_current_subfile ()->language);
 
   if (index_type)
     goto handle_true_range;
diff --git a/gdb/valarith.c b/gdb/valarith.c
index ef376f05936..f3acf98c98b 100644
--- a/gdb/valarith.c
+++ b/gdb/valarith.c
@@ -262,10 +262,8 @@ value_to_array (struct value *val)
 
   if (type->is_array_like ())
     {
-      if (HAVE_GNAT_AUX_INFO (type))
-	return ada_coerce_to_simple_array (val);
-      if (HAVE_RUST_SPECIFIC (type))
-	return rust_slice_to_array (val);
+      const language_defn *defn = language_def (type->language ());
+      return defn->to_array (val);
     }
   return nullptr;
 }

-- 
2.40.1

[PATCH 5/5] Handle pointers and references correctly in DAP

[Tom Tromey]

A user pointed out that the current DAP variable code does not let the
client deference a pointer.  Oops!

Fixing this oversight is simple enough -- adding a new no-op
pretty-printer for pointers and references is quite simple.

However, doing this naive caused a regession in scopes.exp, which
expected there to be no children of a 'const char *' variable.  This
problem was fixed by the preceding patches in the series, which ensure
that a C type of this kind is recognized as a string.

Bug: https://sourceware.org/bugzilla/show_bug.cgi?id=30821
---
 gdb/python/lib/gdb/printing.py   |  16 ++++++
 gdb/testsuite/gdb.dap/ptrref.cc  |  34 +++++++++++++
 gdb/testsuite/gdb.dap/ptrref.exp | 103 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 153 insertions(+)

diff --git a/gdb/python/lib/gdb/printing.py b/gdb/python/lib/gdb/printing.py
index 1a761a6aa57..223a69929d2 100644
--- a/gdb/python/lib/gdb/printing.py
+++ b/gdb/python/lib/gdb/printing.py
@@ -280,6 +280,20 @@ class NoOpScalarPrinter:
         return self.value.format_string(raw=True)
 
 
+class NoOpPointerReferencePrinter:
+    """A no-op pretty printer that wraps a pointer or reference."""
+
+    def __init__(self, value):
+        self.value = value
+        self.num_children = 1
+
+    def to_string(self):
+        return self.value.format_string(deref_refs=False)
+
+    def children(self):
+        yield "value", self.value.referenced_value()
+
+
 class NoOpArrayPrinter:
     """A no-op pretty printer that wraps an array value."""
 
@@ -354,6 +368,8 @@ def make_visualizer(value):
             result = gdb.printing.NoOpArrayPrinter(ty, value)
         elif ty.code in (gdb.TYPE_CODE_STRUCT, gdb.TYPE_CODE_UNION):
             result = gdb.printing.NoOpStructPrinter(ty, value)
+        elif ty.code in (gdb.TYPE_CODE_PTR, gdb.TYPE_CODE_REF, gdb.TYPE_CODE_RVALUE_REF):
+            result = NoOpPointerReferencePrinter(value)
         else:
             result = gdb.printing.NoOpScalarPrinter(value)
     return result
diff --git a/gdb/testsuite/gdb.dap/ptrref.cc b/gdb/testsuite/gdb.dap/ptrref.cc
new file mode 100644
index 00000000000..bfb1afe3d17
--- /dev/null
+++ b/gdb/testsuite/gdb.dap/ptrref.cc
@@ -0,0 +1,34 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 2023 Free Software Foundation, Inc.
+
+   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/>.  */
+
+void
+func ()
+{
+  int value = 23;
+
+  int *ptr = &value;
+  int &ref = value;
+
+  return;			/* BREAK */
+}
+
+int
+main (int argc, char *argv[])
+{
+  func ();
+  return 0;
+}
diff --git a/gdb/testsuite/gdb.dap/ptrref.exp b/gdb/testsuite/gdb.dap/ptrref.exp
new file mode 100644
index 00000000000..e0cc74529ab
--- /dev/null
+++ b/gdb/testsuite/gdb.dap/ptrref.exp
@@ -0,0 +1,103 @@
+# Copyright 2023 Free Software Foundation, Inc.
+
+# 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/>.
+
+require allow_dap_tests
+
+load_lib dap-support.exp
+
+standard_testfile .cc
+
+if {[build_executable ${testfile}.exp $testfile $srcfile {debug c++}] == -1} {
+    return
+}
+
+if {[dap_launch $testfile] == ""} {
+    return
+}
+
+set line [gdb_get_line_number "BREAK"]
+set obj [dap_check_request_and_response "set breakpoint by line number" \
+	     setBreakpoints \
+	     [format {o source [o path [%s]] breakpoints [a [o line [i %d]]]} \
+		  [list s $srcfile] $line]]
+set line_bpno [dap_get_breakpoint_number $obj]
+
+dap_check_request_and_response "start inferior" configurationDone
+dap_wait_for_event_and_check "inferior started" thread "body reason" started
+
+dap_wait_for_event_and_check "stopped at line breakpoint" stopped \
+    "body reason" breakpoint \
+    "body hitBreakpointIds" $line_bpno
+
+set bt [lindex [dap_check_request_and_response "backtrace" stackTrace \
+		    {o threadId [i 1]}] \
+	    0]
+set frame_id [dict get [lindex [dict get $bt body stackFrames] 0] id]
+
+set scopes [dap_check_request_and_response "get scopes" scopes \
+		[format {o frameId [i %d]} $frame_id]]
+set scopes [dict get [lindex $scopes 0] body scopes]
+
+gdb_assert {[llength $scopes] == 2} "two scopes"
+
+lassign $scopes scope reg_scope
+gdb_assert {[dict get $scope name] == "Locals"} "scope is locals"
+
+gdb_assert {[dict get $scope namedVariables] == 3} "three vars in scope"
+
+set num [dict get $scope variablesReference]
+set refs [lindex [dap_check_request_and_response "fetch variables" \
+		      "variables" \
+		      [format {o variablesReference [i %d] count [i 3]} \
+			   $num]] \
+	      0]
+
+proc fetch_pointer {name var} {
+    set num [dict get $var variablesReference]
+    set refs [lindex [dap_check_request_and_response "fetch children of $name" \
+			  "variables" \
+			  [format {o variablesReference [i %d] count [i 1]} \
+			       $num]] \
+		  0]
+    set var [lindex [dict get $refs body variables] 0]
+    gdb_assert {[dict get $var value] == 23} \
+	"value of child of $name"
+    gdb_assert {[dict get $var variablesReference] == 0} \
+	"no children for child of $name"
+}
+
+foreach var [dict get $refs body variables] {
+    set name [dict get $var name]
+
+    switch $name {
+	"value" {
+	    gdb_assert {[dict get $var value] == "23"} "check value of value"
+	    gdb_assert {[dict get $var variablesReference] == 0} \
+		"$name does not have child"
+	}
+	"ptr" -
+	"ref" {
+	    gdb_assert {[dict get $var variablesReference] != 0} \
+		"$name has children"
+	    # The implementation somewhat arbitrarily chooses "named"
+	    # children here.
+	    gdb_assert {[dict get $var namedVariables] == 1} \
+		"$name has exactly one child"
+	    fetch_pointer $name $var
+	}
+    }
+}
+
+dap_shutdown

-- 
2.40.1

Re: [PATCH 0/5] Handle pointers and references correctly in DAP

[Tom Tromey]

>>>>> "Tom" == Tom Tromey via Gdb-patches <gdb-patches@sourceware.org> writes:

Tom> This series started off as a simple implementation of a no-op
Tom> pretty-printer to handle pointers and references in DAP.

Tom> However, this regressed a test, and I realized that the new
Tom> is-array-like and is-string-like code should be generalized to work
Tom> with any language.

Tom> This is done by associating a language with each type, which meant
Tom> touching every debug reader, plus a few minor preliminary cleanups.

Tom> Regression tested on x86-64 Fedora 36.

I'm checking this in now.

Tom