Use std::string in Rust code

This changes a couple of spots in the Rust support to use std::string.
In one spot this removes some manual memory management; in the other
spot this allows the removal of a call to xstrdup.

2017-02-02  Tom Tromey  <tom@tromey.com>

	* rust-lang.h (rust_crate_for_block): Update.
	* rust-lang.c (rust_crate_for_block): Return std::string.
	(rust_get_disr_info): Use std:;string, not
	gdb::unique_xmalloc_ptr.
	* rust-exp.y (crate_name): Update.

4 files changed, 20 insertions, 16 deletions

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 202c90c..cb47f73 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,11 @@
+2017-02-02  Tom Tromey  <tom@tromey.com>
+
+	* rust-lang.h (rust_crate_for_block): Update.
+	* rust-lang.c (rust_crate_for_block): Return std::string.
+	(rust_get_disr_info): Use std:;string, not
+	gdb::unique_xmalloc_ptr.
+	* rust-exp.y (crate_name): Update.
+
 2017-02-02  Pedro Alves  <palves@redhat.com>
 
 	* disasm-selftests.c (print_one_insn_test): Move the "verbose"
diff --git a/gdb/rust-exp.y b/gdb/rust-exp.y
index a97ca67..98301a4 100644
--- a/gdb/rust-exp.y
+++ b/gdb/rust-exp.y
@@ -941,16 +941,15 @@ rust_concat3 (const char *s1, const char *s2, const char *s3)
 static const struct rust_op *
 crate_name (const struct rust_op *name)
 {
-  char *crate = rust_crate_for_block (expression_context_block);
+  std::string crate = rust_crate_for_block (expression_context_block);
   struct stoken result;
 
   gdb_assert (name->opcode == OP_VAR_VALUE);
 
-  if (crate == NULL)
+  if (crate.empty ())
     error (_("Could not find crate for current location"));
-  result = make_stoken (obconcat (&work_obstack, "::", crate, "::",
+  result = make_stoken (obconcat (&work_obstack, "::", crate.c_str (), "::",
 				  name->left.sval.ptr, (char *) NULL));
-  xfree (crate);
 
   return ast_path (result, name->right.params);
 }
diff --git a/gdb/rust-lang.c b/gdb/rust-lang.c
index dd72cd9..17df6bb 100644
--- a/gdb/rust-lang.c
+++ b/gdb/rust-lang.c
@@ -51,19 +51,17 @@ rust_last_path_segment (const char * path)
   return result + 1;
 }
 
-/* Find the Rust crate for BLOCK.  If no crate can be found, returns
-   NULL.  Otherwise, returns a newly allocated string that the caller
-   is responsible for freeing.  */
+/* See rust-lang.h.  */
 
-char *
+std::string
 rust_crate_for_block (const struct block *block)
 {
   const char *scope = block_scope (block);
 
   if (scope[0] == '\0')
-    return NULL;
+    return std::string ();
 
-  return xstrndup (scope, cp_find_first_component (scope));
+  return std::string (scope, cp_find_first_component (scope));
 }
 
 /* Information about the discriminant/variant of an enum */
@@ -157,8 +155,8 @@ rust_get_disr_info (struct type *type, const gdb_byte *valaddr,
       /* Optimized enums have only one field.  */
       member_type = TYPE_FIELD_TYPE (type, 0);
 
-      gdb::unique_xmalloc_ptr<char> name (xstrdup (TYPE_FIELD_NAME (type, 0)));
-      tail = name.get () + strlen (RUST_ENUM_PREFIX);
+      std::string name (TYPE_FIELD_NAME (type, 0));
+      tail = &name[0] + strlen (RUST_ENUM_PREFIX);
 
       /* The location of the value that doubles as a discriminant is
          stored in the name of the field, as
diff --git a/gdb/rust-lang.h b/gdb/rust-lang.h
index 70da69f..6c627ae 100644
--- a/gdb/rust-lang.h
+++ b/gdb/rust-lang.h
@@ -35,10 +35,9 @@ extern int rust_tuple_type_p (struct type *type);
 /* Return true if TYPE is a tuple struct type; otherwise false.  */
 extern int rust_tuple_struct_type_p (struct type *type);
 
-/* Given a block, find the name of the block's crate.  The name must
-   be freed by the caller.  Returns NULL if no crate name can be
-   found.  */
-extern char *rust_crate_for_block (const struct block *block);
+/* Given a block, find the name of the block's crate. Returns an empty
+   stringif no crate name can be found.  */
+extern std::string rust_crate_for_block (const struct block *block);
 
 /* Create a new slice type.  NAME is the name of the type.  ELT_TYPE
    is the type of the elements of the slice.  USIZE_TYPE is the Rust