Testcase and fix for bug 24074

[ravitheja]

Summary

In bug 24074, the type information is not shown
correctly. This commit includes the following -
-> Changes for displaying correct type based on
current lexical scope for the command "image
lookup -t"

-> The corresponding testcase.

-> This patch was reverted due to segfaults in
FreeBSD and Mac, I fixed the problems for both now.

[clayborg]

Back from vacation, sorry for the delay. Looks good.

[ravitheja]

Adding the testcase

include/lldb/Core/Module.h

private:
     Module (); // Only used internally by CreateJITModule ()
     
     size_t
     FindTypes_Impl (const SymbolContext& sc, 
                     const ConstString &name,
                     const CompilerDeclContext *parent_decl_ctx,
                     bool append, 
                     size_t max_matches,
-                    TypeList& types);
+                    TypeMap& types);
 
     
     DISALLOW_COPY_AND_ASSIGN (Module);
 };
 
 } // namespace lldb_private
 
 #endif  // liblldb_Module_h_

include/lldb/Symbol/SymbolContext.h

public:
     ///     is a method of a class, \b false otherwise.
     //------------------------------------------------------------------
     bool
     GetFunctionMethodInfo (lldb::LanguageType &language,
                            bool &is_instance_method,
                            ConstString &language_object_name);
 
     //------------------------------------------------------------------
+    /// Sorts the types in TypeMap according to SymbolContext
+    /// to TypeList
+    ///
+    //------------------------------------------------------------------
+    void
+  SortTypeList(TypeMap &type_map, TypeList &type_list) const;
+    //------------------------------------------------------------------
     /// Find a name of the innermost function for the symbol context.
     ///
     /// For instance, if the symbol context contains an inlined block,
     /// it will return the inlined function name.
     ///
     /// @param[in] prefer_mangled
     ///    if \btrue, then the mangled name will be returned if there
     ///    is one.  Otherwise the unmangled name will be returned if it

include/lldb/Symbol/SymbolFile.h

public:
     virtual CompilerDeclContext GetDeclContextForUID (lldb::user_id_t uid) { return CompilerDeclContext(); }
     virtual CompilerDeclContext GetDeclContextContainingUID (lldb::user_id_t uid) { return CompilerDeclContext(); }
     virtual uint32_t        ResolveSymbolContext (const Address& so_addr, uint32_t resolve_scope, SymbolContext& sc) = 0;
     virtual uint32_t        ResolveSymbolContext (const FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, SymbolContextList& sc_list);
     virtual uint32_t        FindGlobalVariables (const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, VariableList& variables);
     virtual uint32_t        FindGlobalVariables (const RegularExpression& regex, bool append, uint32_t max_matches, VariableList& variables);
     virtual uint32_t        FindFunctions (const ConstString &name, const CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask, bool include_inlines, bool append, SymbolContextList& sc_list);
     virtual uint32_t        FindFunctions (const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list);
-    virtual uint32_t        FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, TypeList& types);
+    virtual uint32_t        FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, TypeMap& types);
 //  virtual uint32_t        FindTypes (const SymbolContext& sc, const RegularExpression& regex, bool append, uint32_t max_matches, TypeList& types) = 0;
     virtual TypeList *      GetTypeList ();
     virtual size_t          GetTypes (lldb_private::SymbolContextScope *sc_scope,
                                       uint32_t type_mask,
                                       lldb_private::TypeList &type_list) = 0;
 
     virtual lldb_private::TypeSystem *
                             GetTypeSystemForLanguage (lldb::LanguageType language);

include/lldb/Symbol/SymbolVendor.h

 #define liblldb_SymbolVendor_h_
 
 #include <vector>
 
 #include "lldb/lldb-private.h"
 #include "lldb/Core/ModuleChild.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/TypeList.h"
+#include "lldb/Symbol/TypeMap.h"
 
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 // The symbol vendor class is designed to abstract the process of
 // searching for debug information for a given module. Platforms can
 // subclass this class and provide extra ways to find debug information.
 // Examples would be a subclass that would allow for locating a stand
FindFunctions (const RegularExpression& regex,
                    SymbolContextList& sc_list);
 
     virtual size_t
     FindTypes (const SymbolContext& sc, 
                const ConstString &name,
                const CompilerDeclContext *parent_decl_ctx, 
                bool append, 
                size_t max_matches,
-               TypeList& types);
+               TypeMap& types);
 
     virtual CompilerDeclContext
     FindNamespace (const SymbolContext& sc, 
                    const ConstString &name,
                    const CompilerDeclContext *parent_decl_ctx);
     
     virtual size_t
     GetNumCompileUnits();

include/lldb/Symbol/TypeList.h

 //===-- TypeList.h ----------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_TypeList_h_
 #define liblldb_TypeList_h_
 
 #include "lldb/lldb-private.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Utility/Iterable.h"
-#include <map>
+#include <vector>
 #include <functional>
 
 namespace lldb_private {
 
 class TypeList
 {
 public:
     //------------------------------------------------------------------
     // Constructors and Destructors
     //------------------------------------------------------------------
-    TypeList();
+  TypeList();
 
     virtual
     ~TypeList();
 
     void
     Clear();
 
     void
     Dump(Stream *s, bool show_context);
 
 //    lldb::TypeSP
 //    FindType(lldb::user_id_t uid);
 
     TypeList
     FindTypes(const ConstString &name);
 
     void
     Insert (const lldb::TypeSP& type);
 
-    bool
-    InsertUnique (const lldb::TypeSP& type);
-
     uint32_t
     GetSize() const;
 
     lldb::TypeSP
     GetTypeAtIndex(uint32_t idx);
     
-    typedef std::multimap<lldb::user_id_t, lldb::TypeSP> collection;
-    typedef AdaptedIterable<collection, lldb::TypeSP, map_adapter> TypeIterable;
+    typedef std::vector<lldb::TypeSP> collection;
+    typedef AdaptedIterable<collection, lldb::TypeSP, vector_adapter> TypeIterable;
     
     TypeIterable
     Types ()
     {
         return TypeIterable(m_types);
     }
 
     void
     ForEach (std::function <bool(const lldb::TypeSP &type_sp)> const &callback) const;
 
     void
     ForEach (std::function <bool(lldb::TypeSP &type_sp)> const &callback);
 
-    bool
-    RemoveTypeWithUID (lldb::user_id_t uid);
 
     void
     RemoveMismatchedTypes (const char *qualified_typename,
                            bool exact_match);
 
     void
     RemoveMismatchedTypes (const std::string &type_scope,
                            const std::string &type_basename,

include/lldb/Symbol/TypeMap.h

+//===-- TypeMap.h ----------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_TypeMap_h_
+#define liblldb_TypeMap_h_
+
+#include "lldb/lldb-private.h"
+#include "lldb/Symbol/Type.h"
+#include "lldb/Utility/Iterable.h"
+#include <map>
+#include <functional>
+
+namespace lldb_private {
+
+class TypeMap
+{
+public:
+    //------------------------------------------------------------------
+    // Constructors and Destructors
+    //------------------------------------------------------------------
+  TypeMap();
+
+    virtual
+    ~TypeMap();
+
+    void
+    Clear();
+
+    void
+    Dump(Stream *s, bool show_context);
+
+//    lldb::TypeSP
+//    FindType(lldb::user_id_t uid);
+
+    TypeMap
+    FindTypes(const ConstString &name);
+
+    void
+    Insert (const lldb::TypeSP& type);
+
+    bool
+    Empty() const;
+
+    bool
+    InsertUnique (const lldb::TypeSP& type);
+
+    uint32_t
+    GetSize() const;
+
+    lldb::TypeSP
+    GetTypeAtIndex(uint32_t idx);
+    
+    typedef std::multimap<lldb::user_id_t, lldb::TypeSP> collection;
+    typedef AdaptedIterable<collection, lldb::TypeSP, map_adapter> TypeIterable;
+    
+    TypeIterable
+    Types ()
+    {
+        return TypeIterable(m_types);
+    }
+
+    void
+    ForEach (std::function <bool(const lldb::TypeSP &type_sp)> const &callback) const;
+
+    void
+    ForEach (std::function <bool(lldb::TypeSP &type_sp)> const &callback);
+
+    bool
+    RemoveTypeWithUID (lldb::user_id_t uid);
+
+    void
+    RemoveMismatchedTypes (const char *qualified_typename,
+                           bool exact_match);
+
+    void
+    RemoveMismatchedTypes (const std::string &type_scope,
+                           const std::string &type_basename,
+                           lldb::TypeClass type_class,
+                           bool exact_match);
+
+    void
+    RemoveMismatchedTypes (lldb::TypeClass type_class);
+
+private:
+    typedef collection::iterator iterator;
+    typedef collection::const_iterator const_iterator;
+
+    collection m_types;
+
+    DISALLOW_COPY_AND_ASSIGN (TypeMap);
+};
+
+} // namespace lldb_private
+
+#endif  // liblldb_TypeMap_h_

include/lldb/lldb-forward.h

 class   ThreadPlanTracer;
 class   ThreadSpec;
 class   TimeValue;
 class   Type;
 class   TypeAndOrName;
 class   TypeCategoryMap;
 class   TypeImpl;
 class   TypeList;
+class   TypeMap;
 class   TypeListImpl;
 class   TypeMemberImpl;
 class   TypeMemberFunctionImpl;
 class   TypeEnumMemberImpl;
 class   TypeEnumMemberListImpl;
 class   TypeFormatImpl;
 class   TypeNameSpecifierImpl;
 class   TypePair;

lldb.xcodeproj/project.pbxproj

/* Begin PBXBuildFile section */
     6D55B2921A8A806200A70529 /* GDBRemoteCommunicationServerPlatform.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D55B28F1A8A806200A70529 /* GDBRemoteCommunicationServerPlatform.cpp */; };
     6D55BAED1A8CD0A800A70529 /* PlatformAndroid.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D55BAE91A8CD08C00A70529 /* PlatformAndroid.cpp */; };
     6D55BAEE1A8CD0B200A70529 /* PlatformAndroidRemoteGDBServer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D55BAEB1A8CD08C00A70529 /* PlatformAndroidRemoteGDBServer.cpp */; };
     6D762BEE1B1605D2006C929D /* LLDBServerUtilities.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D762BEC1B1605CD006C929D /* LLDBServerUtilities.cpp */; };
     6D86CEA01B440F8500A7FBFA /* CommandObjectBugreport.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D86CE9E1B440F6B00A7FBFA /* CommandObjectBugreport.cpp */; };
     6D95DC001B9DC057000E318A /* DIERef.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D95DBFD1B9DC057000E318A /* DIERef.cpp */; };
     6D95DC011B9DC057000E318A /* HashedNameToDIE.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D95DBFE1B9DC057000E318A /* HashedNameToDIE.cpp */; };
     6D95DC021B9DC057000E318A /* SymbolFileDWARFDwo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D95DBFF1B9DC057000E318A /* SymbolFileDWARFDwo.cpp */; };
+    6D9AB3DD1BB2B74E003F2289 /* TypeMap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D9AB3DC1BB2B74E003F2289 /* TypeMap.cpp */; };
     6D99A3631BBC2F3200979793 /* ArmUnwindInfo.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 6D99A3621BBC2F3200979793 /* ArmUnwindInfo.cpp */; };
     8C2D6A53197A1EAF006989C9 /* MemoryHistory.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C2D6A52197A1EAF006989C9 /* MemoryHistory.cpp */; };
     8C2D6A5E197A250F006989C9 /* MemoryHistoryASan.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8C2D6A5A197A1FDC006989C9 /* MemoryHistoryASan.cpp */; };
     8CCB017E19BA28A80009FD44 /* ThreadCollection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CCB017A19BA283D0009FD44 /* ThreadCollection.cpp */; };
     8CCB018219BA4E270009FD44 /* SBThreadCollection.h in Headers */ = {isa = PBXBuildFile; fileRef = 8CCB018119BA4E210009FD44 /* SBThreadCollection.h */; settings = {ATTRIBUTES = (Public, ); }; };
     8CCB018319BA51BF0009FD44 /* SBThreadCollection.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CCB017F19BA4DD00009FD44 /* SBThreadCollection.cpp */; };
     8CF02AE919DCC01900B14BE0 /* InstrumentationRuntime.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CF02ADF19DCBF3B00B14BE0 /* InstrumentationRuntime.cpp */; };
     8CF02AEA19DCC02100B14BE0 /* AddressSanitizerRuntime.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8CF02AE519DCBF8400B14BE0 /* AddressSanitizerRuntime.cpp */; };

     6D762BED1B1605CD006C929D /* LLDBServerUtilities.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = LLDBServerUtilities.h; path = "tools/lldb-server/LLDBServerUtilities.h"; sourceTree = "<group>"; };
     6D86CE9E1B440F6B00A7FBFA /* CommandObjectBugreport.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; name = CommandObjectBugreport.cpp; path = source/Commands/CommandObjectBugreport.cpp; sourceTree = "<group>"; };
     6D86CE9F1B440F6B00A7FBFA /* CommandObjectBugreport.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = CommandObjectBugreport.h; path = source/Commands/CommandObjectBugreport.h; sourceTree = "<group>"; };
     6D95DBFD1B9DC057000E318A /* DIERef.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DIERef.cpp; sourceTree = "<group>"; };
     6D95DBFE1B9DC057000E318A /* HashedNameToDIE.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = HashedNameToDIE.cpp; sourceTree = "<group>"; };
     6D95DBFF1B9DC057000E318A /* SymbolFileDWARFDwo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = SymbolFileDWARFDwo.cpp; sourceTree = "<group>"; };
     6D95DC031B9DC06F000E318A /* DIERef.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DIERef.h; sourceTree = "<group>"; };
     6D95DC041B9DC06F000E318A /* SymbolFileDWARFDwo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = SymbolFileDWARFDwo.h; sourceTree = "<group>"; };
+    6D9AB3DC1BB2B74E003F2289 /* TypeMap.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = TypeMap.cpp; path = source/Symbol/TypeMap.cpp; sourceTree = "<group>"; };
+    6D9AB3DE1BB2B76B003F2289 /* TypeMap.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = TypeMap.h; path = include/lldb/Symbol/TypeMap.h; sourceTree = "<group>"; };
     6D99A3611BBC2F1600979793 /* ArmUnwindInfo.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = ArmUnwindInfo.h; path = include/lldb/Symbol/ArmUnwindInfo.h; sourceTree = "<group>"; };
     6D99A3621BBC2F3200979793 /* ArmUnwindInfo.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ArmUnwindInfo.cpp; path = source/Symbol/ArmUnwindInfo.cpp; sourceTree = "<group>"; };
     8C2D6A52197A1EAF006989C9 /* MemoryHistory.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = MemoryHistory.cpp; path = source/Target/MemoryHistory.cpp; sourceTree = "<group>"; };
     8C2D6A54197A1EBE006989C9 /* MemoryHistory.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = MemoryHistory.h; path = include/lldb/Target/MemoryHistory.h; sourceTree = "<group>"; };
     8C2D6A5A197A1FDC006989C9 /* MemoryHistoryASan.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = MemoryHistoryASan.cpp; sourceTree = "<group>"; };
     8C2D6A5B197A1FDC006989C9 /* MemoryHistoryASan.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = MemoryHistoryASan.h; sourceTree = "<group>"; };
     8CCB017A19BA283D0009FD44 /* ThreadCollection.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ThreadCollection.cpp; path = source/Target/ThreadCollection.cpp; sourceTree = "<group>"; };
     8CCB017C19BA289B0009FD44 /* ThreadCollection.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = ThreadCollection.h; path = include/lldb/Target/ThreadCollection.h; sourceTree = "<group>"; };
26BC7C1010F1B34800F91463 /* Core */ = {
         26BC7E9E10F1B85900F91463 /* VMRange.cpp */,
       );
       name = Core;
       sourceTree = "<group>";
     };
     26BC7C4B10F1B6C100F91463 /* Symbol */ = {
       isa = PBXGroup;
       children = (
+        6D9AB3DE1BB2B76B003F2289 /* TypeMap.h */,
+        6D9AB3DC1BB2B74E003F2289 /* TypeMap.cpp */,
         6D99A3621BBC2F3200979793 /* ArmUnwindInfo.cpp */,
         6D99A3611BBC2F1600979793 /* ArmUnwindInfo.h */,
         26BC7C5510F1B6E900F91463 /* Block.h */,
         26BC7F1310F1B8EC00F91463 /* Block.cpp */,
         26BC7C5610F1B6E900F91463 /* ClangASTContext.h */,
         26BC7F1410F1B8EC00F91463 /* ClangASTContext.cpp */,
         49D8FB3713B5594900411094 /* ClangASTImporter.h */,
         49D8FB3513B558DE00411094 /* ClangASTImporter.cpp */,
2689FFC613353D7A00698AC0 /* Sources */ = {
         26D7E45D13D5E30A007FD12B /* SocketAddress.cpp in Sources */,
         94CD7D0C19A3FBCE00908B7C /* AppleObjCTypeEncodingParser.cpp in Sources */,
         94B6E76213D88365005F417F /* ValueObjectSyntheticFilter.cpp in Sources */,
         267A47FF1B1411D90021A5BC /* NativeWatchpointList.cpp in Sources */,
         26F4A21C13FBA31A0064B613 /* ThreadMemory.cpp in Sources */,
         3FBA69E11B6067120008F44A /* ScriptInterpreterNone.cpp in Sources */,
         266DFE9713FD656E00D0C574 /* OperatingSystem.cpp in Sources */,
         26954EBE1401EE8B00294D09 /* DynamicRegisterInfo.cpp in Sources */,
+        6D9AB3DD1BB2B74E003F2289 /* TypeMap.cpp in Sources */,
         255EFF761AFABA950069F277 /* LockFilePosix.cpp in Sources */,
         3FBA69EC1B6067430008F44A /* PythonDataObjects.cpp in Sources */,
         26274FA714030F79006BA130 /* DynamicLoaderDarwinKernel.cpp in Sources */,
         94FA3DE01405D50400833217 /* ValueObjectConstResultChild.cpp in Sources */,
         3FDFED2819BA6D96009756A7 /* HostThread.cpp in Sources */,
         949ADF031406F648004833E1 /* ValueObjectConstResultImpl.cpp in Sources */,
         B27318421416AC12006039C8 /* WatchpointList.cpp in Sources */,
         26CFDCA3186163A4000E63E5 /* Editline.cpp in Sources */,

source/Core/Module.cpp

 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
+#include "lldb/Symbol/TypeMap.h"
 
 #include "Plugins/ObjectFile/JIT/ObjectFileJIT.h"
 
 #include "llvm/Support/raw_os_ostream.h"
 #include "llvm/Support/Signals.h"
 
 using namespace lldb;
 using namespace lldb_private;

 }
 
 size_t
 Module::FindTypes_Impl (const SymbolContext& sc,
                         const ConstString &name,
                         const CompilerDeclContext *parent_decl_ctx,
                         bool append,
                         size_t max_matches,
-                        TypeList& types)
+                        TypeMap& types)
 {
     Timer scoped_timer(__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
     if (sc.module_sp.get() == NULL || sc.module_sp.get() == this)
     {
         SymbolVendor *symbols = GetSymbolVendor ();
         if (symbols)
             return symbols->FindTypes(sc, name, parent_decl_ctx, append, max_matches, types);
     }
     return 0;
 }
 
 size_t
 Module::FindTypesInNamespace (const SymbolContext& sc,
                               const ConstString &type_name,
                               const CompilerDeclContext *parent_decl_ctx,
                               size_t max_matches,
                               TypeList& type_list)
 {
     const bool append = true;
-    return FindTypes_Impl(sc, type_name, parent_decl_ctx, append, max_matches, type_list);
+    TypeMap types_map;
+    size_t num_types = FindTypes_Impl(sc, type_name, parent_decl_ctx, append, max_matches, types_map);
+    if (num_types > 0)
+        sc.SortTypeList(types_map, type_list);
+    return num_types;
 }
 
 lldb::TypeSP
 Module::FindFirstType (const SymbolContext& sc,
                        const ConstString &name,
                        bool exact_match)
 {
     TypeList type_list;
Module::FindTypes (const SymbolContext& sc,
                    TypeList& types)
 {
     size_t num_matches = 0;
     const char *type_name_cstr = name.GetCString();
     std::string type_scope;
     std::string type_basename;
     const bool append = true;
     TypeClass type_class = eTypeClassAny;
+    TypeMap typesmap;
     if (Type::GetTypeScopeAndBasename (type_name_cstr, type_scope, type_basename, type_class))
     {
         // Check if "name" starts with "::" which means the qualified type starts
         // from the root namespace and implies and exact match. The typenames we
         // get back from clang do not start with "::" so we need to strip this off
         // in order to get the qualified names to match
 
         if (type_scope.size() >= 2 && type_scope[0] == ':' && type_scope[1] == ':')
         {
             type_scope.erase(0,2);
             exact_match = true;
         }
         ConstString type_basename_const_str (type_basename.c_str());
-        if (FindTypes_Impl(sc, type_basename_const_str, NULL, append, max_matches, types))
+        if (FindTypes_Impl(sc, type_basename_const_str, NULL, append, max_matches, typesmap))
         {
-            types.RemoveMismatchedTypes (type_scope, type_basename, type_class, exact_match);
-            num_matches = types.GetSize();
+            typesmap.RemoveMismatchedTypes (type_scope, type_basename, type_class, exact_match);
+            num_matches = typesmap.GetSize();
         }
     }
     else
     {
         // The type is not in a namespace/class scope, just search for it by basename
         if (type_class != eTypeClassAny)
         {
             // The "type_name_cstr" will have been modified if we have a valid type class
             // prefix (like "struct", "class", "union", "typedef" etc).
-            FindTypes_Impl(sc, ConstString(type_name_cstr), NULL, append, max_matches, types);
-            types.RemoveMismatchedTypes (type_class);
-            num_matches = types.GetSize();
+            FindTypes_Impl(sc, ConstString(type_name_cstr), NULL, append, max_matches, typesmap);
+            typesmap.RemoveMismatchedTypes (type_class);
+            num_matches = typesmap.GetSize();
         }
         else
         {
-            num_matches = FindTypes_Impl(sc, name, NULL, append, max_matches, types);
+            num_matches = FindTypes_Impl(sc, name, NULL, append, max_matches, typesmap);
         }
     }
-    
+    if (num_matches > 0)
+        sc.SortTypeList(typesmap, types);
     return num_matches;
-    
 }
 
 SymbolVendor*
 Module::GetSymbolVendor (bool can_create, lldb_private::Stream *feedback_strm)
 {
     if (m_did_load_symbol_vendor.load() == false)
     {
         Mutex::Locker locker (m_mutex);

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

FindFunctions (const lldb_private::RegularExpression& regex,
                    lldb_private::SymbolContextList& sc_list) override;
 
     uint32_t
     FindTypes (const lldb_private::SymbolContext& sc,
                const lldb_private::ConstString &name,
                const lldb_private::CompilerDeclContext *parent_decl_ctx,
                bool append,
                uint32_t max_matches,
-               lldb_private::TypeList& types) override;
+               lldb_private::TypeMap& types) override;
 
     lldb_private::TypeList *
     GetTypeList () override;
 
     size_t
     GetTypes (lldb_private::SymbolContextScope *sc_scope,
               uint32_t type_mask,
               lldb_private::TypeList &type_list) override;

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Symbol/VariableList.h"
+#include "lldb/Symbol/TypeMap.h"
 
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 
 #include "lldb/Target/Language.h"
 
 #include "DWARFASTParser.h"
 #include "DWARFCompileUnit.h"

 }
 
 uint32_t
 SymbolFileDWARF::FindTypes (const SymbolContext& sc, 
                             const ConstString &name, 
                             const CompilerDeclContext *parent_decl_ctx, 
                             bool append, 
                             uint32_t max_matches, 
-                            TypeList& types)
+                            TypeMap& types)
 {
     DWARFDebugInfo* info = DebugInfo();
     if (info == NULL)
         return 0;
 
     Log *log (LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
     if (log)
SymbolFileDWARF::GetTypeForDIE (const DWARFDIE &die)
     if (die)
     {
         Type *type_ptr = GetDIEToType().lookup (die.GetDIE());
         if (type_ptr == NULL)
         {
             CompileUnit* lldb_cu = GetCompUnitForDWARFCompUnit(die.GetCU());
             assert (lldb_cu);
             SymbolContext sc(lldb_cu);
+            const DWARFDebugInfoEntry* parent_die = die.GetParent().GetDIE();
+            while (parent_die != nullptr)
+                {
+                    if (parent_die->Tag() == DW_TAG_subprogram)
+                        break;
+                    parent_die = parent_die->GetParent();
+                }
+            SymbolContext sc_backup = sc;
+            if (parent_die != nullptr && !GetFunction(DWARFDIE(die.GetCU(),parent_die), sc))
+                sc = sc_backup;
+
             type_sp = ParseType(sc, die, NULL);
         }
         else if (type_ptr != DIE_IS_BEING_PARSED)
         {
             // Grab the existing type from the master types lists
             type_sp = type_ptr->shared_from_this();
         }
 

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

public:
 
     bool            CompleteType (lldb_private::CompilerType& compiler_type) override;
     uint32_t        ResolveSymbolContext (const lldb_private::Address& so_addr, uint32_t resolve_scope, lldb_private::SymbolContext& sc) override;
     uint32_t        ResolveSymbolContext (const lldb_private::FileSpec& file_spec, uint32_t line, bool check_inlines, uint32_t resolve_scope, lldb_private::SymbolContextList& sc_list) override;
     uint32_t        FindGlobalVariables (const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, lldb_private::VariableList& variables) override;
     uint32_t        FindGlobalVariables (const lldb_private::RegularExpression& regex, bool append, uint32_t max_matches, lldb_private::VariableList& variables) override;
     uint32_t        FindFunctions (const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, uint32_t name_type_mask, bool include_inlines, bool append, lldb_private::SymbolContextList& sc_list) override;
     uint32_t        FindFunctions (const lldb_private::RegularExpression& regex, bool include_inlines, bool append, lldb_private::SymbolContextList& sc_list) override;
-    uint32_t        FindTypes (const lldb_private::SymbolContext& sc, const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, lldb_private::TypeList& types) override;
+    uint32_t        FindTypes (const lldb_private::SymbolContext& sc, const lldb_private::ConstString &name, const lldb_private::CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, lldb_private::TypeMap& types) override;
     lldb_private::CompilerDeclContext
                     FindNamespace (const lldb_private::SymbolContext& sc,
                                    const lldb_private::ConstString &name,
                                    const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
     size_t          GetTypes (lldb_private::SymbolContextScope *sc_scope,
                               uint32_t type_mask,
                               lldb_private::TypeList &type_list) override;
 

source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

 #include "lldb/Core/StreamFile.h"
 #endif
 #include "lldb/Core/Timer.h"
 
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
+#include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/VariableList.h"
 
 #include "LogChannelDWARF.h"
 #include "SymbolFileDWARF.h"
 
 using namespace lldb;
 using namespace lldb_private;
 

 uint32_t
 SymbolFileDWARFDebugMap::FindTypes 
 (
     const SymbolContext& sc, 
     const ConstString &name,
     const CompilerDeclContext *parent_decl_ctx,
     bool append,
     uint32_t max_matches, 
-    TypeList& types
+    TypeMap& types
 )
 {
     if (!append)
         types.Clear();
 
     const uint32_t initial_types_size = types.GetSize();
     SymbolFileDWARF *oso_dwarf;
 

source/Symbol/CMakeLists.txt

add_lldb_library(lldbSymbol
   ObjectFile.cpp
   Symbol.cpp
   SymbolContext.cpp
   SymbolFile.cpp
   SymbolVendor.cpp
   Symtab.cpp
   Type.cpp
   TypeList.cpp
+  TypeMap.cpp 
   TypeSystem.cpp
   UnwindPlan.cpp
   UnwindTable.cpp
   Variable.cpp
   VariableList.cpp
   VerifyDecl.cpp
   )

source/Symbol/SymbolContext.cpp

SymbolContext::GetFunctionMethodInfo (lldb::LanguageType &language,
     {
         CompilerDeclContext decl_ctx = function_block->GetDeclContext();
         if (decl_ctx)
             return decl_ctx.IsClassMethod(&language, &is_instance_method, &language_object_name);
     }
     return false;
 }
 
+class TypeMoveMatchingBlock
+{
+public:
+    TypeMoveMatchingBlock(Block * block, TypeMap &typem, TypeList &typel) :
+        curr_block(block),type_map(typem),type_list(typel)
+    {
+    }
+
+    bool
+    operator() (const lldb::TypeSP& type)
+    {
+        if (type && type->GetSymbolContextScope() != nullptr && curr_block == type->GetSymbolContextScope()->CalculateSymbolContextBlock())
+        {
+            type_list.Insert(type);
+            type_map.RemoveTypeWithUID(type->GetID());
+            return false;
+        }
+        return true;
+    }
+
+private:
+    const Block * const curr_block;
+    TypeMap &type_map;
+    TypeList &type_list;
+};
+
+class TypeMoveMatchingFunction
+{
+public:
+    TypeMoveMatchingFunction(Function * block, TypeMap &typem, TypeList &typel) :
+        func(block),type_map(typem),type_list(typel)
+    {
+    }
+
+    bool
+    operator() (const lldb::TypeSP& type)
+    {
+        if (type && type->GetSymbolContextScope() != nullptr && func == type->GetSymbolContextScope()->CalculateSymbolContextFunction())
+        {
+            type_list.Insert(type);
+            type_map.RemoveTypeWithUID(type->GetID());
+            return false;
+        }
+        return true;
+    }
+
+private:
+    const Function * const func;
+    TypeMap &type_map;
+    TypeList &type_list;
+};
+
+class TypeMoveMatchingCompileUnit
+{
+public:
+    TypeMoveMatchingCompileUnit(CompileUnit * cunit, TypeMap &typem, TypeList &typel) :
+        comp_unit(cunit),type_map(typem),type_list(typel)
+    {
+    }
+
+    bool
+    operator() (const lldb::TypeSP& type)
+    {
+        if (type && type->GetSymbolContextScope() != nullptr && comp_unit == type->GetSymbolContextScope()->CalculateSymbolContextCompileUnit())
+        {
+            type_list.Insert(type);
+            type_map.RemoveTypeWithUID(type->GetID());
+            return false;
+        }
+        return true;
+    }
+
+private:
+    const CompileUnit * const comp_unit;
+    TypeMap &type_map;
+    TypeList &type_list;
+};
+
+class TypeMoveMatchingModule
+{
+public:
+    TypeMoveMatchingModule(lldb::ModuleSP modsp, TypeMap &typem, TypeList &typel) :
+        modulesp(modsp),type_map(typem),type_list(typel)
+    {
+    }
+
+    bool
+    operator() (const lldb::TypeSP& type)
+    {
+        if (type && type->GetSymbolContextScope() != nullptr && modulesp.get() == type->GetSymbolContextScope()->CalculateSymbolContextModule().get())
+        {
+            type_list.Insert(type);
+            type_map.RemoveTypeWithUID(type->GetID());
+            return false;
+        }
+        return true;
+    }
+
+private:
+    lldb::ModuleSP modulesp;
+    TypeMap &type_map;
+    TypeList &type_list;
+};
+
+class TypeMaptoList
+{
+public:
+    TypeMaptoList(TypeMap &typem, TypeList &typel) :
+        type_map(typem),type_list(typel)
+    {
+    }
+
+    bool
+    operator() (const lldb::TypeSP& type)
+    {
+        if(type)
+        {
+            type_list.Insert(type);
+            type_map.RemoveTypeWithUID(type->GetID());
+            if (type_map.Empty())
+                return false;
+        }
+        return true;
+    }
+
+private:
+    TypeMap &type_map;
+    TypeList &type_list;
+};
+
+void
+SymbolContext::SortTypeList(TypeMap &type_map, TypeList &type_list ) const
+{
+    Block * curr_block = block;
+    bool isInlinedblock = false;
+    if (curr_block != nullptr && curr_block->GetContainingInlinedBlock() != nullptr)
+        isInlinedblock = true;
+
+    while (curr_block != nullptr && !isInlinedblock)
+    {
+        TypeMoveMatchingBlock callbackBlock (curr_block, type_map, type_list);
+        type_map.ForEach(callbackBlock);
+        curr_block = curr_block->GetParent();
+    }
+    if(function != nullptr && type_map.GetSize() > 0)
+    {
+        TypeMoveMatchingFunction callbackFunction (function, type_map, type_list);
+        type_map.ForEach(callbackFunction);
+    }
+    if(comp_unit != nullptr && type_map.GetSize() > 0)
+    {
+        TypeMoveMatchingCompileUnit callbackCompileUnit (comp_unit, type_map, type_list);
+        type_map.ForEach(callbackCompileUnit);
+    }
+    if(module_sp && type_map.GetSize() > 0)
+    {
+        TypeMoveMatchingModule callbackModule (module_sp, type_map, type_list);
+        type_map.ForEach(callbackModule);
+    }
+    if(type_map.GetSize() > 0)
+    {
+        TypeMaptoList callbackM2L (type_map, type_list);
+        type_map.ForEach(callbackM2L);
+
+    }
+  return ;
+}
+
 ConstString
 SymbolContext::GetFunctionName (Mangled::NamePreference preference) const
 {
     if (function)
     {
         if (block)
         {
             Block *inlined_block = block->GetContainingInlinedBlock();

source/Symbol/SymbolFile.cpp

 #include "lldb/Symbol/SymbolFile.h"
 
 #include "lldb/lldb-private.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Symbol/ObjectFile.h"
-#include "lldb/Symbol/TypeList.h"
+#include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Symbol/VariableList.h"
 
 using namespace lldb_private;
 
 SymbolFile*
 SymbolFile::FindPlugin (ObjectFile* obj_file)
 {

 SymbolFile::FindFunctions (const RegularExpression& regex, bool include_inlines, bool append, SymbolContextList& sc_list)
 {
     if (!append)
         sc_list.Clear();
     return 0;
 }
 
 uint32_t
-SymbolFile::FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, TypeList& types)
+SymbolFile::FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, uint32_t max_matches, TypeMap& types)
 {
     if (!append)
         types.Clear();
     return 0;
 }
 

source/Symbol/SymbolVendor.cpp

if (module_sp)
         if (m_sym_file_ap.get())
             return m_sym_file_ap->FindFunctions(regex, include_inlines, append, sc_list);
     }
     return 0;
 }
 
 
 size_t
-SymbolVendor::FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, size_t max_matches, TypeList& types)
+SymbolVendor::FindTypes (const SymbolContext& sc, const ConstString &name, const CompilerDeclContext *parent_decl_ctx, bool append, size_t max_matches, TypeMap& types)
 {
     ModuleSP module_sp(GetModule());
     if (module_sp)
     {
         lldb_private::Mutex::Locker locker(module_sp->GetMutex());
         if (m_sym_file_ap.get())
             return m_sym_file_ap->FindTypes(sc, name, parent_decl_ctx, append, max_matches, types);
     }

source/Symbol/TypeList.cpp

 {
 }
 
 void
 TypeList::Insert (const TypeSP& type_sp)
 {
     // Just push each type on the back for now. We will worry about uniquing later
     if (type_sp)
-        m_types.insert(std::make_pair(type_sp->GetID(), type_sp));
-}
-
-
-bool
-TypeList::InsertUnique (const TypeSP& type_sp)
-{
-    if (type_sp)
-    {
-        user_id_t type_uid = type_sp->GetID();
-        iterator pos, end = m_types.end();
-        
-        for (pos = m_types.find(type_uid); pos != end && pos->second->GetID() == type_uid; ++pos)
-        {
-            if (pos->second.get() == type_sp.get())
-                return false;
-        }
-    }
-    Insert (type_sp);
-    return true;
+        m_types.push_back(type_sp);
 }
 
 //----------------------------------------------------------------------
 // Find a base type by its unique ID.
 //----------------------------------------------------------------------
 //TypeSP
 //TypeList::FindType(lldb::user_id_t uid)
 //{

 TypeSP
 TypeList::GetTypeAtIndex(uint32_t idx)
 {
     iterator pos, end;
     uint32_t i = idx;
     for (pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
     {
         if (i == 0)
-            return pos->second;
+            return *pos;
         --i;
     }
     return TypeSP();
 }
 
 void
 TypeList::ForEach (std::function <bool(const lldb::TypeSP &type_sp)> const &callback) const
 {
     for (auto pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
     {
-        if (!callback(pos->second))
+        if (!callback(*pos))
             break;
     }
 }
 
 void
 TypeList::ForEach (std::function <bool(lldb::TypeSP &type_sp)> const &callback)
 {
     for (auto pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
     {
-        if (!callback(pos->second))
+        if (!callback(*pos))
             break;
     }
 }
 
-
-bool
-TypeList::RemoveTypeWithUID (user_id_t uid)
-{
-    iterator pos = m_types.find(uid);
-    
-    if (pos != m_types.end())
-    {
-        m_types.erase(pos);
-        return true;
-    }
-    return false;
-}
-
-
 void
 TypeList::Dump(Stream *s, bool show_context)
 {
     for (iterator pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
     {
-        pos->second->Dump(s, show_context);
+        pos->get()->Dump(s, show_context);
     }
 }
 
 void
 TypeList::RemoveMismatchedTypes (const char *qualified_typename,
                                  bool exact_match)
 {
     std::string type_scope;
TypeList::RemoveMismatchedTypes (const std::string &type_scope,
     // so we currently just make a new list and add all of the matching
     // types to it, and then swap it into m_types at the end
     collection matching_types;
 
     iterator pos, end = m_types.end();
     
     for (pos = m_types.begin(); pos != end; ++pos)
     {
-        Type* the_type = pos->second.get();
+        Type* the_type = pos->get();
         bool keep_match = false;
         TypeClass match_type_class = eTypeClassAny;
 
         if (type_class != eTypeClassAny)
         {
             match_type_class = the_type->GetForwardCompilerType ().GetTypeClass ();
             if ((match_type_class & type_class) == 0)
                 continue;
for (pos = m_types.begin(); pos != end; ++pos)
                 // in a namespace or class, so it only matches if there
                 // is no type scope...
                 keep_match = type_scope.empty() && type_basename.compare(match_type_name) == 0;
             }
         }
         
         if (keep_match)
         {
-            matching_types.insert (*pos);
+            matching_types.push_back(*pos);
         }
     }
     m_types.swap(matching_types);
 }
 
 void
 TypeList::RemoveMismatchedTypes (TypeClass type_class)
 {
     if (type_class == eTypeClassAny)
         return;
 
     // Our "collection" type currently is a std::map which doesn't
     // have any good way to iterate and remove items from the map
     // so we currently just make a new list and add all of the matching
     // types to it, and then swap it into m_types at the end
     collection matching_types;
     
     iterator pos, end = m_types.end();
     
     for (pos = m_types.begin(); pos != end; ++pos)
     {
-        Type* the_type = pos->second.get();
+        Type* the_type = pos->get();
         TypeClass match_type_class = the_type->GetForwardCompilerType ().GetTypeClass ();
         if (match_type_class & type_class)
-            matching_types.insert (*pos);
+            matching_types.push_back (*pos);
     }
     m_types.swap(matching_types);
 }

source/Symbol/TypeMap.cpp

+//===-- TypeMap.cpp --------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+
+// C Includes
+// C++ Includes
+#include <vector>
+
+// Other libraries and framework includes
+#include "clang/AST/ASTConsumer.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/AST/DeclGroup.h"
+
+#include "clang/Basic/Builtins.h"
+#include "clang/Basic/IdentifierTable.h"
+#include "clang/Basic/LangOptions.h"
+#include "clang/Basic/SourceManager.h"
+#include "clang/Basic/TargetInfo.h"
+
+#include "llvm/Support/FormattedStream.h"
+#include "llvm/Support/raw_ostream.h"
+
+// Project includes
+#include "lldb/Symbol/SymbolFile.h"
+#include "lldb/Symbol/SymbolVendor.h"
+#include "lldb/Symbol/Type.h"
+#include "lldb/Symbol/TypeMap.h"
+
+using namespace lldb;
+using namespace lldb_private;
+using namespace clang;
+
+TypeMap::TypeMap() :
+    m_types ()
+{
+}
+
+//----------------------------------------------------------------------
+// Destructor
+//----------------------------------------------------------------------
+TypeMap::~TypeMap()
+{
+}
+
+void
+TypeMap::Insert (const TypeSP& type_sp)
+{
+    // Just push each type on the back for now. We will worry about uniquing later
+    if (type_sp)
+        m_types.insert(std::make_pair(type_sp->GetID(), type_sp));
+}
+
+
+bool
+TypeMap::InsertUnique (const TypeSP& type_sp)
+{
+    if (type_sp)
+    {
+        user_id_t type_uid = type_sp->GetID();
+        iterator pos, end = m_types.end();
+        
+        for (pos = m_types.find(type_uid); pos != end && pos->second->GetID() == type_uid; ++pos)
+        {
+            if (pos->second.get() == type_sp.get())
+                return false;
+        }
+    }
+    Insert (type_sp);
+    return true;
+}
+
+//----------------------------------------------------------------------
+// Find a base type by its unique ID.
+//----------------------------------------------------------------------
+//TypeSP
+//TypeMap::FindType(lldb::user_id_t uid)
+//{
+//    iterator pos = m_types.find(uid);
+//    if (pos != m_types.end())
+//        return pos->second;
+//    return TypeSP();
+//}
+
+//----------------------------------------------------------------------
+// Find a type by name.
+//----------------------------------------------------------------------
+//TypeMap
+//TypeMap::FindTypes (const ConstString &name)
+//{
+//    // Do we ever need to make a lookup by name map? Here we are doing
+//    // a linear search which isn't going to be fast.
+//    TypeMap types(m_ast.getTargetInfo()->getTriple().getTriple().c_str());
+//    iterator pos, end;
+//    for (pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
+//        if (pos->second->GetName() == name)
+//            types.Insert (pos->second);
+//    return types;
+//}
+
+void
+TypeMap::Clear()
+{
+    m_types.clear();
+}
+
+uint32_t
+TypeMap::GetSize() const
+{
+    return m_types.size();
+}
+
+bool
+TypeMap::Empty() const
+{
+    return m_types.empty();
+}
+
+// GetTypeAtIndex isn't used a lot for large type lists, currently only for
+// type lists that are returned for "image dump -t TYPENAME" commands and other
+// simple symbol queries that grab the first result...
+
+TypeSP
+TypeMap::GetTypeAtIndex(uint32_t idx)
+{
+    iterator pos, end;
+    uint32_t i = idx;
+    for (pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
+    {
+        if (i == 0)
+            return pos->second;
+        --i;
+    }
+    return TypeSP();
+}
+
+void
+TypeMap::ForEach (std::function <bool(const lldb::TypeSP &type_sp)> const &callback) const
+{
+    for (auto pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
+    {
+        if (!callback(pos->second))
+            break;
+    }
+}
+
+void
+TypeMap::ForEach (std::function <bool(lldb::TypeSP &type_sp)> const &callback)
+{
+    for (auto pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
+    {
+        if (!callback(pos->second))
+            break;
+    }
+}
+
+
+bool
+TypeMap::RemoveTypeWithUID (user_id_t uid)
+{
+    iterator pos = m_types.find(uid);
+    
+    if (pos != m_types.end())
+    {
+        m_types.erase(pos);
+        return true;
+    }
+    return false;
+}
+
+
+void
+TypeMap::Dump(Stream *s, bool show_context)
+{
+    for (iterator pos = m_types.begin(), end = m_types.end(); pos != end; ++pos)
+    {
+        pos->second->Dump(s, show_context);
+    }
+}
+
+void
+TypeMap::RemoveMismatchedTypes (const char *qualified_typename,
+                                 bool exact_match)
+{
+    std::string type_scope;
+    std::string type_basename;
+    TypeClass type_class = eTypeClassAny;
+    if (!Type::GetTypeScopeAndBasename (qualified_typename, type_scope, type_basename, type_class))
+    {
+        type_basename = qualified_typename;
+        type_scope.clear();
+    }
+    return RemoveMismatchedTypes (type_scope, type_basename, type_class, exact_match);
+}
+
+void
+TypeMap::RemoveMismatchedTypes (const std::string &type_scope,
+                                 const std::string &type_basename,
+                                 TypeClass type_class,
+                                 bool exact_match)
+{
+    // Our "collection" type currently is a std::map which doesn't
+    // have any good way to iterate and remove items from the map
+    // so we currently just make a new list and add all of the matching
+    // types to it, and then swap it into m_types at the end
+    collection matching_types;
+
+    iterator pos, end = m_types.end();
+    
+    for (pos = m_types.begin(); pos != end; ++pos)
+    {
+        Type* the_type = pos->second.get();
+        bool keep_match = false;
+        TypeClass match_type_class = eTypeClassAny;
+
+        if (type_class != eTypeClassAny)
+        {
+            match_type_class = the_type->GetForwardCompilerType ().GetTypeClass ();
+            if ((match_type_class & type_class) == 0)
+                continue;
+        }
+
+        ConstString match_type_name_const_str (the_type->GetQualifiedName());
+        if (match_type_name_const_str)
+        {
+            const char *match_type_name = match_type_name_const_str.GetCString();
+            std::string match_type_scope;
+            std::string match_type_basename;
+            if (Type::GetTypeScopeAndBasename (match_type_name,
+                                               match_type_scope,
+                                               match_type_basename,
+                                               match_type_class))
+            {
+                if (match_type_basename == type_basename)
+                {
+                    const size_t type_scope_size = type_scope.size();
+                    const size_t match_type_scope_size = match_type_scope.size();
+                    if (exact_match || (type_scope_size == match_type_scope_size))
+                    {
+                        keep_match = match_type_scope == type_scope;
+                    }
+                    else
+                    {
+                        if (match_type_scope_size > type_scope_size)
+                        {
+                            const size_t type_scope_pos = match_type_scope.rfind(type_scope);
+                            if (type_scope_pos == match_type_scope_size - type_scope_size)
+                            {
+                                if (type_scope_pos >= 2)
+                                {
+                                    // Our match scope ends with the type scope we were looking for,
+                                    // but we need to make sure what comes before the matching
+                                    // type scope is a namespace boundary in case we are trying to match:
+                                    // type_basename = "d"
+                                    // type_scope = "b::c::"
+                                    // We want to match:
+                                    //  match_type_scope "a::b::c::"
+                                    // But not:
+                                    //  match_type_scope "a::bb::c::"
+                                    // So below we make sure what comes before "b::c::" in match_type_scope
+                                    // is "::", or the namespace boundary
+                                    if (match_type_scope[type_scope_pos - 1] == ':' &&
+                                        match_type_scope[type_scope_pos - 2] == ':')
+                                    {
+                                        keep_match = true;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            else
+            {
+                // The type we are currently looking at doesn't exists
+                // in a namespace or class, so it only matches if there
+                // is no type scope...
+                keep_match = type_scope.empty() && type_basename.compare(match_type_name) == 0;
+            }
+        }
+        
+        if (keep_match)
+        {
+            matching_types.insert (*pos);
+        }
+    }
+    m_types.swap(matching_types);
+}
+
+void
+TypeMap::RemoveMismatchedTypes (TypeClass type_class)
+{
+    if (type_class == eTypeClassAny)
+        return;
+
+    // Our "collection" type currently is a std::map which doesn't
+    // have any good way to iterate and remove items from the map
+    // so we currently just make a new list and add all of the matching
+    // types to it, and then swap it into m_types at the end
+    collection matching_types;
+    
+    iterator pos, end = m_types.end();
+    
+    for (pos = m_types.begin(); pos != end; ++pos)
+    {
+        Type* the_type = pos->second.get();
+        TypeClass match_type_class = the_type->GetForwardCompilerType ().GetTypeClass ();
+        if (match_type_class & type_class)
+            matching_types.insert (*pos);
+    }
+    m_types.swap(matching_types);
+}

test/lang/c/typedef/Makefile

+LEVEL = ../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules

test/lang/c/typedef/Testtypedef.py

+"""Look up type information for typedefs of same name at different lexical scope and check for correct display."""
+
+import os, time
+import unittest2
+import lldb
+from lldbtest import *
+import lldbutil
+
+class TypedefTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipUnlessDarwin
+    @dsym_test
+    @expectedFailureClang("llvm.org/pr19238")
+    def test_with_dsym(self):
+        """Test 'image lookup -t a' and check for correct display at different scopes."""
+        self.buildDsym()
+        self.image_lookup_for_multiple_typedefs()
+
+    @dwarf_test
+    @expectedFailureClang("llvm.org/pr19238")
+    def test_with_dwarf(self):
+        """Test 'image lookup -t a' and check for correct display at different scopes."""
+        self.buildDwarf()
+        self.image_lookup_for_multiple_typedefs()
+
+    def image_lookup_for_multiple_typedefs(self):
+        """Test 'image lookup -t a' at different scopes and check for correct display."""
+        exe = os.path.join(os.getcwd(), "a.out")
+        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+        typearray = ("float", "float", "char", "float", "int", "double", "float", "float")
+        arraylen = len(typearray)+1
+        for i in range(1,arraylen):
+            loc_line = line_number('main.c', '// Set break point ' + str(i) + '.')
+            lldbutil.run_break_set_by_file_and_line (self, "main.c",loc_line, num_expected_locations=1, loc_exact=True)
+
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        for t in typearray:
+            self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ['stopped', 'stop reason = breakpoint'])
+            self.expect("image lookup -t a", DATA_TYPES_DISPLAYED_CORRECTLY,
+            substrs = ['name = "' + t + '"'])
+            self.runCmd("continue")
+
+if __name__ == '__main__':
+    import atexit
+    lldb.SBDebugger.Initialize()
+    atexit.register(lambda: lldb.SBDebugger.Terminate())
+    unittest2.main()

test/lang/c/typedef/main.c

+//===-- main.c --------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+int main (int argc, char const *argv[])
+{
+    typedef float a;
+    int i = 0; // Set break point 1.
+    i++;
+    a floatvariable = 2.7; // Set break point 2.
+    {
+        typedef char a;
+        i++;
+        a charvariable = 'a'; // Set break point 3.
+    }
+    {
+        int c = 0;
+        c++; // Set break point 4.
+        for(i = 0 ; i < 1 ; i++)
+        {
+            typedef int a;
+            a b;
+            b = 7; // Set break point 5.
+        }
+        for(i = 0 ; i < 1 ; i++)
+        {
+            typedef double a;
+            a b;
+            b = 3.14; // Set break point 6.
+        }
+        c = 1; // Set break point 7.
+    }
+    floatvariable = 2.5;
+    floatvariable = 2.8; // Set break point 8.
+    return 0;
+}