[binutils-gdb] [D] Fix regression in py-lookup-type.exp

[Iain Buclaw <ibuclaw at sourceware dot org>]

https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=ba587d55a56db16e9e47d1e0975f5125fbafc6db

commit ba587d55a56db16e9e47d1e0975f5125fbafc6db
Author: Iain Buclaw <ibuclaw@gdcproject.org>
Date:   Sat Sep 26 09:08:12 2015 +0200

    [D] Fix regression in py-lookup-type.exp
    
    In the console interpreter, primitive types are resolved in the expression
    parser.  However that didn't take into consideration the script interface.
    
    gdb/ChangeLog:
    
    	* d-namespace.c (d_lookup_symbol): New arg langdef.
    	All callers updated.  Support looking up symbol as a primitive type.
    	(lookup_module_scope): New arg langdef.  All callers updated.
    	Call d_lookup_symbol directly for simple bare symbols.

Diff:
---
 gdb/ChangeLog     |  7 +++++++
 gdb/d-namespace.c | 41 ++++++++++++++++++++++++++++++++++-------
 2 files changed, 41 insertions(+), 7 deletions(-)

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index 26266c6..ec7d672 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,10 @@
+2015-09-26  Iain Buclaw  <ibuclaw@gdcproject.org>
+
+	* d-namespace.c (d_lookup_symbol): New arg langdef.
+	All callers updated.  Support looking up symbol as a primitive type.
+	(lookup_module_scope): New arg langdef.  All callers updated.
+	Call d_lookup_symbol directly for simple bare symbols.
+
 2015-09-25  Simon Marchi  <simon.marchi@ericsson.com>
 
 	* macrocmd.c (print_macro_callback): Add cast(s).
diff --git a/gdb/d-namespace.c b/gdb/d-namespace.c
index 9e00710..e8f4c6f 100644
--- a/gdb/d-namespace.c
+++ b/gdb/d-namespace.c
@@ -74,7 +74,8 @@ d_entire_prefix_len (const char *name)
    symbol.  Other arguments are as in d_lookup_symbol_nonlocal.  */
 
 static struct block_symbol
-d_lookup_symbol (const char *name, const struct block *block,
+d_lookup_symbol (const struct language_defn *langdef,
+		 const char *name, const struct block *block,
 		 const domain_enum domain, int search)
 {
   struct block_symbol sym;
@@ -83,6 +84,23 @@ d_lookup_symbol (const char *name, const struct block *block,
   if (sym.symbol != NULL)
     return sym;
 
+  /* If we didn't find a definition for a builtin type in the static block,
+     such as "ucent" which is a specialist type, search for it now.  */
+  if (langdef != NULL && domain == VAR_DOMAIN)
+    {
+      struct gdbarch *gdbarch;
+
+      if (block == NULL)
+	gdbarch = target_gdbarch ();
+      else
+	gdbarch = block_gdbarch (block);
+      sym.symbol
+	= language_lookup_primitive_type_as_symbol (langdef, gdbarch, name);
+      sym.block = NULL;
+      if (sym.symbol != NULL)
+	return sym;
+    }
+
   sym = lookup_global_symbol (name, block, domain);
 
   if (sym.symbol != NULL)
@@ -174,7 +192,7 @@ d_lookup_symbol_in_module (const char *module, const char *name,
       name = concatenated_name;
     }
 
-  return d_lookup_symbol (name, block, domain, search);
+  return d_lookup_symbol (NULL, name, block, domain, search);
 }
 
 /* Lookup NAME at module scope.  SCOPE is the module that the current
@@ -190,7 +208,8 @@ d_lookup_symbol_in_module (const char *module, const char *name,
    and if that call fails, then the first call looks for "x".  */
 
 static struct block_symbol
-lookup_module_scope (const char *name, const struct block *block,
+lookup_module_scope (const struct language_defn *langdef,
+		     const char *name, const struct block *block,
 		     const domain_enum domain, const char *scope,
 		     int scope_len)
 {
@@ -210,14 +229,22 @@ lookup_module_scope (const char *name, const struct block *block,
 	  new_scope_len++;
 	}
       new_scope_len += d_find_first_component (scope + new_scope_len);
-      sym = lookup_module_scope (name, block, domain,
+      sym = lookup_module_scope (langdef, name, block, domain,
 				 scope, new_scope_len);
       if (sym.symbol != NULL)
 	return sym;
     }
 
   /* Okay, we didn't find a match in our children, so look for the
-     name in the current module.  */
+     name in the current module.
+
+     If we there is no scope and we know we have a bare symbol, then short
+     circuit everything and call d_lookup_symbol directly.
+     This isn't an optimization, rather it allows us to pass LANGDEF which
+     is needed for primitive type lookup.  */
+
+  if (scope_len == 0 && strchr (name, '.') == NULL)
+    return d_lookup_symbol (langdef, name, block, domain, 1);
 
   module = (char *) alloca (scope_len + 1);
   strncpy (module, scope, scope_len);
@@ -465,7 +492,7 @@ d_lookup_symbol_imports (const char *scope, const char *name,
 		  /* If the alias matches the sought name.  Pass
 		     current->import_src as the NAME to direct the
 		     search towards the aliased module.  */
-		  sym = lookup_module_scope (current->import_src, block,
+		  sym = lookup_module_scope (NULL, current->import_src, block,
 					     domain, scope, 0);
 		}
 	      else
@@ -554,7 +581,7 @@ d_lookup_symbol_nonlocal (const struct language_defn *langdef,
   struct block_symbol sym;
   const char *scope = block_scope (block);
 
-  sym = lookup_module_scope (name, block, domain, scope, 0);
+  sym = lookup_module_scope (langdef, name, block, domain, scope, 0);
   if (sym.symbol != NULL)
     return sym;