diff --git a/source/Core/Debugger.cpp b/source/Core/Debugger.cpp
index 5ad5227..8be3da0 100644
--- a/source/Core/Debugger.cpp
+++ b/source/Core/Debugger.cpp
@@ -155,8 +155,7 @@
     m_command_interpreter_ap (new CommandInterpreter (*this, eScriptLanguageDefault, false)),
     m_exe_ctx (),
     m_input_readers (),
-    m_input_reader_data (),
-    m_use_external_editor(false)
+    m_input_reader_data ()
 {
     m_command_interpreter_ap->Initialize ();
 }
diff --git a/source/Host/macosx/Host.mm b/source/Host/macosx/Host.mm
index 05e8833..e3379d0 100644
--- a/source/Host/macosx/Host.mm
+++ b/source/Host/macosx/Host.mm
@@ -12,11 +12,13 @@
 #include "lldb/Core/Log.h"
 
 #include "cfcpp/CFCBundle.h"
+#include "cfcpp/CFCMutableDictionary.h"
 #include "cfcpp/CFCReleaser.h"
 #include "cfcpp/CFCString.h"
 
 #include <objc/objc-auto.h>
 
+#include <ApplicationServices/ApplicationServices.h>
 #include <Carbon/Carbon.h>
 #include <Foundation/Foundation.h>
 
@@ -112,8 +114,44 @@
   return false;
 }
 
+lldb::pid_t
+Host::LaunchApplication (const FileSpec &app_file_spec)
+{
+    char app_path[PATH_MAX];
+    app_file_spec.GetPath(app_path, sizeof(app_path));
+
+    LSApplicationParameters app_params;
+    ::bzero (&app_params, sizeof (app_params));
+    app_params.flags = kLSLaunchDefaults | 
+                       kLSLaunchDontAddToRecents | 
+                       kLSLaunchDontSwitch |
+                       kLSLaunchNewInstance;// | 0x00001000;
+    
+    FSRef app_fsref;
+    CFCString app_cfstr (app_path, kCFStringEncodingUTF8);
+    
+    OSStatus error = ::FSPathMakeRef ((const UInt8 *)app_path, &app_fsref, false);
+    
+    // If we found the app, then store away the name so we don't have to re-look it up.
+    if (error != noErr)
+        return LLDB_INVALID_PROCESS_ID;
+    
+    app_params.application = &app_fsref;
+
+    ProcessSerialNumber psn;
+
+    error = ::LSOpenApplication (&app_params, &psn);
+
+    if (error != noErr)
+        return LLDB_INVALID_PROCESS_ID;
+
+    ::pid_t pid = LLDB_INVALID_PROCESS_ID;
+    error = ::GetProcessPID(&psn, &pid);
+    return pid;
+}
+
 bool
-Host::OpenFileInExternalEditor (FileSpec &file_spec, uint32_t line_no)
+Host::OpenFileInExternalEditor (const FileSpec &file_spec, uint32_t line_no)
 {
     // We attach this to an 'odoc' event to specify a particular selection
     typedef struct {
diff --git a/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp b/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
index f0c33f6..d84fedd 100644
--- a/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
+++ b/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
@@ -366,6 +366,7 @@
     return error;
 }
 
+//#define LAUNCH_WITH_LAUNCH_SERVICES 1
 //----------------------------------------------------------------------
 // Process Control
 //----------------------------------------------------------------------
@@ -381,10 +382,18 @@
     const char *stderr_path
 )
 {
+    Error error;
+#if defined (LAUNCH_WITH_LAUNCH_SERVICES)
+    FileSpec app_file_spec (argv[0]);
+    pid_t pid = Host::LaunchApplication (app_file_spec);
+    if (pid != LLDB_INVALID_PROCESS_ID)
+        error = DoAttachToProcessWithID (pid);
+    else
+        error.SetErrorString("failed");
+#else
     //  ::LogSetBitMask (GDBR_LOG_DEFAULT);
     //  ::LogSetOptions (LLDB_LOG_OPTION_THREADSAFE | LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_PROC_AND_THREAD);
     //  ::LogSetLogFile ("/dev/stdout");
-    Error error;
 
     ObjectFile * object_file = module->GetObjectFile();
     if (object_file)
@@ -497,9 +506,9 @@
         SetID(LLDB_INVALID_PROCESS_ID);
         error.SetErrorStringWithFormat("Failed to get object file from '%s' for arch %s.\n", module->GetFileSpec().GetFilename().AsCString(), module->GetArchitecture().AsCString());
     }
-
-    // Return the process ID we have
+#endif
     return error;
+
 }
 
 
@@ -621,9 +630,13 @@
 void
 ProcessGDBRemote::DidLaunch ()
 {
+#if defined (LAUNCH_WITH_LAUNCH_SERVICES)
+    DidAttach ();
+#else
     DidLaunchOrAttach ();
     if (m_dynamic_loader_ap.get())
         m_dynamic_loader_ap->DidLaunch();
+#endif
 }
 
 Error
diff --git a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
index 6b735d2..0452ea3 100644
--- a/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
+++ b/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
@@ -2444,7 +2444,7 @@
             DWARFDebugInfoEntry::Attributes attributes;
             const char *type_name_cstr = NULL;
             ConstString type_name_dbstr;
-            Type::EncodingUIDType encoding_uid_type = Type::eIsTypeWithUID;
+            Type::EncodingDataType encoding_data_type = Type::eEncodingIsUID;
             clang_type_t clang_type = NULL;
 
             TypeList* type_list = m_obj_file->GetModule()->GetTypeList();
@@ -2508,37 +2508,37 @@
                     case DW_TAG_pointer_type:
                         // The encoding_uid will be embedded into the
                         // Type object and will be looked up when the Type::GetClangType()
-                        encoding_uid_type = Type::ePointerToTypeWithUID;
+                        encoding_data_type = Type::eEncodingIsPointerUID;
                         break;
 
                     case DW_TAG_reference_type:
                         // The encoding_uid will be embedded into the
                         // Type object and will be looked up when the Type::GetClangType()
-                        encoding_uid_type = Type::eLValueReferenceToTypeWithUID;
+                        encoding_data_type = Type::eEncodingIsLValueReferenceUID;
                         break;
 
                     case DW_TAG_typedef:
                         // The encoding_uid will be embedded into the
                         // Type object and will be looked up when the Type::GetClangType()
-                        encoding_uid_type = Type::eTypedefToTypeWithUID;
+                        encoding_data_type = Type::eEncodingIsTypedefUID;
                         break;
 
                     case DW_TAG_const_type:
                         // The encoding_uid will be embedded into the
                         // Type object and will be looked up when the Type::GetClangType()
-                        encoding_uid_type = Type::eIsConstTypeWithUID; //ClangASTContext::AddConstModifier (clang_type);
+                        encoding_data_type = Type::eEncodingIsConstUID; //ClangASTContext::AddConstModifier (clang_type);
                         break;
 
                     case DW_TAG_restrict_type:
                         // The encoding_uid will be embedded into the
                         // Type object and will be looked up when the Type::GetClangType()
-                        encoding_uid_type = Type::eIsRestrictTypeWithUID; //ClangASTContext::AddRestrictModifier (clang_type);
+                        encoding_data_type = Type::eEncodingIsRestrictUID; //ClangASTContext::AddRestrictModifier (clang_type);
                         break;
 
                     case DW_TAG_volatile_type:
                         // The encoding_uid will be embedded into the
                         // Type object and will be looked up when the Type::GetClangType()
-                        encoding_uid_type = Type::eIsVolatileTypeWithUID; //ClangASTContext::AddVolatileModifier (clang_type);
+                        encoding_data_type = Type::eEncodingIsVolatileUID; //ClangASTContext::AddVolatileModifier (clang_type);
                         break;
                     }
 
@@ -2563,7 +2563,7 @@
                         }
                     }
                         
-                    type_sp.reset( new Type(die->GetOffset(), this, type_name_dbstr, byte_size, NULL, encoding_uid, encoding_uid_type, &decl, clang_type));
+                    type_sp.reset( new Type(die->GetOffset(), this, type_name_dbstr, byte_size, NULL, encoding_uid, encoding_data_type, &decl, clang_type, clang_type == NULL));
 
                     m_die_to_type[die] = type_sp.get();
 
@@ -2679,21 +2679,27 @@
                     // parameters in any class methods need it for the clang 
                     // types for function prototypes. 
                     m_die_to_decl_ctx[die] = ClangASTContext::GetDeclContextForType (clang_type);
-                    type_sp.reset( new Type(die->GetOffset(), this, type_name_dbstr, byte_size, NULL, LLDB_INVALID_UID, Type::eIsTypeWithUID, &decl, clang_type));
+                    type_sp.reset( new Type(die->GetOffset(), this, type_name_dbstr, byte_size, NULL, LLDB_INVALID_UID, Type::eEncodingIsUID, &decl, clang_type, true));
 
                     m_die_to_type[die] = type_sp.get();
 
-                    // Leave this as a forward declaration until we need
-                    // to know the details of the type. lldb_private::Type
-                    // will automatically call the SymbolFile virtual function
-                    // "SymbolFileDWARF::ResolveClangOpaqueTypeDefinition(Type *)"
-                    // When the definition needs to be defined.
-                    if (clang_type_was_created)
+                    if (die->HasChildren() == false)
                     {
+                        // No children for this struct/union/class, lets finish it
+                        type_list->GetClangASTContext().StartTagDeclarationDefinition (clang_type);
+                        type_list->GetClangASTContext().CompleteTagDeclarationDefinition (clang_type);
+                    }
+                    else if (clang_type_was_created)
+                    {
+                        // Leave this as a forward declaration until we need
+                        // to know the details of the type. lldb_private::Type
+                        // will automatically call the SymbolFile virtual function
+                        // "SymbolFileDWARF::ResolveClangOpaqueTypeDefinition(Type *)"
+                        // When the definition needs to be defined.
                         m_forward_decl_die_to_clang_type[die] = clang_type;
                         m_forward_decl_clang_type_to_die[clang_type] = die;
                     }
-
+                    
                 }
                 break;
 
@@ -2760,7 +2766,7 @@
                         }
 
                         m_die_to_decl_ctx[die] = ClangASTContext::GetDeclContextForType (clang_type);
-                        type_sp.reset( new Type(die->GetOffset(), this, type_name_dbstr, byte_size, NULL, encoding_uid, Type::eIsTypeWithUID, &decl, clang_type));
+                        type_sp.reset( new Type(die->GetOffset(), this, type_name_dbstr, byte_size, NULL, encoding_uid, Type::eEncodingIsUID, &decl, clang_type, true));
 
                         m_die_to_type[die] = type_sp.get();
 
@@ -2972,7 +2978,7 @@
                                     type_list->GetClangASTContext().SetFunctionParameters (function_decl, &function_param_decls.front(), function_param_decls.size());
                             }
                         }
-                        type_sp.reset( new Type(die->GetOffset(), this, type_name_dbstr, 0, NULL, LLDB_INVALID_UID, Type::eIsTypeWithUID, &decl, clang_type));
+                        type_sp.reset( new Type(die->GetOffset(), this, type_name_dbstr, 0, NULL, LLDB_INVALID_UID, Type::eEncodingIsUID, &decl, clang_type, false));
 
                         m_die_to_type[die] = type_sp.get();
                         assert(type_sp.get());
@@ -3057,7 +3063,7 @@
                                 array_element_bit_stride = array_element_bit_stride * num_elements;
                             }
                             ConstString empty_name;
-                            type_sp.reset( new Type(die->GetOffset(), this, empty_name, array_element_bit_stride / 8, NULL, LLDB_INVALID_UID, Type::eIsTypeWithUID, &decl, clang_type));
+                            type_sp.reset( new Type(die->GetOffset(), this, empty_name, array_element_bit_stride / 8, NULL, LLDB_INVALID_UID, Type::eEncodingIsUID, &decl, clang_type, false));
                             m_die_to_type[die] = type_sp.get();
                         }
                     }
@@ -3099,7 +3105,7 @@
 
                         size_t byte_size = ClangASTType::GetClangTypeBitWidth (type_list->GetClangASTContext().getASTContext(), clang_type) / 8;
 
-                        type_sp.reset( new Type(die->GetOffset(), this, type_name_dbstr, byte_size, NULL, LLDB_INVALID_UID, Type::eIsTypeWithUID, NULL, clang_type));
+                        type_sp.reset( new Type(die->GetOffset(), this, type_name_dbstr, byte_size, NULL, LLDB_INVALID_UID, Type::eEncodingIsUID, NULL, clang_type, false));
                         m_die_to_type[die] = type_sp.get();
                     }
                                             
diff --git a/source/Symbol/Function.cpp b/source/Symbol/Function.cpp
index 41a708c..52b1356 100644
--- a/source/Symbol/Function.cpp
+++ b/source/Symbol/Function.cpp
@@ -414,7 +414,7 @@
     // Null out everything below the CompUnit 'cause we don't actually know these.
 
     size_t bit_size = ClangASTType::GetClangTypeBitWidth ((GetType()->GetClangASTContext().getASTContext()), fun_return_qualtype.getAsOpaquePtr());
-    Type return_type (0, GetType()->GetSymbolFile(), fun_return_name, bit_size, sc.comp_unit, 0, Type::eTypeUIDSynthetic, Declaration(), fun_return_qualtype.getAsOpaquePtr());
+    Type return_type (0, GetType()->GetSymbolFile(), fun_return_name, bit_size, sc.comp_unit, 0, Type::eEncodingIsSyntheticUID, Declaration(), fun_return_qualtype.getAsOpaquePtr(), false);
     return return_type;
 }
 
@@ -455,7 +455,7 @@
         // Null out everything below the CompUnit 'cause we don't actually know these.
 
         size_t bit_size = ClangASTType::GetClangTypeBitWidth ((GetType()->GetClangASTContext().getASTContext()), arg_qualtype.getAsOpaquePtr());
-        Type arg_type (0, GetType()->GetSymbolFile(), arg_return_name, bit_size, sc.comp_unit, 0, Type::eTypeUIDSynthetic, Declaration(), arg_qualtype.getAsOpaquePtr());
+        Type arg_type (0, GetType()->GetSymbolFile(), arg_return_name, bit_size, sc.comp_unit, 0, Type::eEncodingIsSyntheticUID, Declaration(), arg_qualtype.getAsOpaquePtr(), false);
         return arg_type;
     }
 
diff --git a/source/Symbol/Type.cpp b/source/Symbol/Type.cpp
index a4f0410..4605dff 100644
--- a/source/Symbol/Type.cpp
+++ b/source/Symbol/Type.cpp
@@ -33,22 +33,24 @@
     lldb::user_id_t uid,
     SymbolFile* symbol_file,
     const ConstString &name,
-    uint64_t byte_size,
+    uint32_t byte_size,
     SymbolContextScope *context,
-    lldb::user_id_t encoding_uid,
-    EncodingUIDType encoding_uid_type,
+    uintptr_t encoding_data,
+    EncodingDataType encoding_data_type,
     const Declaration& decl,
-    clang_type_t clang_type
+    clang_type_t clang_type,
+    bool is_forward_decl
 ) :
     UserID (uid),
     m_name (name),
-    m_byte_size (byte_size),
     m_symbol_file (symbol_file),
     m_context (context),
-    m_encoding_uid (encoding_uid),
-    m_encoding_uid_type (encoding_uid_type),
+    m_byte_size (byte_size),
+    m_encoding_data_type (encoding_data_type),
+    m_encoding_data (encoding_data),
     m_decl (decl),
-    m_clang_qual_type (clang_type)
+    m_clang_qual_type (clang_type),
+    m_is_forward_decl (is_forward_decl)
 {
 }
 
@@ -58,10 +60,11 @@
     m_byte_size (0),
     m_symbol_file (NULL),
     m_context (),
-    m_encoding_uid (0),
-    m_encoding_uid_type (eTypeInvalid),
+    m_encoding_data (0),
+    m_encoding_data_type (eEncodingInvalid),
     m_decl (),
-    m_clang_qual_type (NULL)
+    m_clang_qual_type (NULL),
+    m_is_forward_decl (false)
 {
 }
 
@@ -76,7 +79,7 @@
         m_byte_size = rhs.m_byte_size;
         m_symbol_file = rhs.m_symbol_file;
         m_context = rhs.m_context;
-        m_encoding_uid = rhs.m_encoding_uid;
+        m_encoding_data = rhs.m_encoding_data;
         m_decl = rhs.m_decl;
         m_clang_qual_type = rhs.m_clang_qual_type;
     }
@@ -105,19 +108,21 @@
         ClangASTType::DumpTypeDescription (GetClangAST(), m_clang_qual_type, s);
         *s << '"';
     }
-    else if (m_encoding_uid != LLDB_INVALID_UID)
+    else if (m_encoding_data != LLDB_INVALID_UID)
     {
-        s->Printf(", type_uid = 0x%8.8x", m_encoding_uid);
-        switch (m_encoding_uid_type)
+        s->Printf(", type_uid = 0x%8.8x", m_encoding_data);
+        switch (m_encoding_data_type)
         {
-        case eIsTypeWithUID: s->PutCString(" (unresolved type)"); break;
-        case eIsConstTypeWithUID: s->PutCString(" (unresolved const type)"); break;
-        case eIsRestrictTypeWithUID: s->PutCString(" (unresolved restrict type)"); break;
-        case eIsVolatileTypeWithUID: s->PutCString(" (unresolved volatile type)"); break;
-        case eTypedefToTypeWithUID: s->PutCString(" (unresolved typedef)"); break;
-        case ePointerToTypeWithUID: s->PutCString(" (unresolved pointer)"); break;
-        case eLValueReferenceToTypeWithUID: s->PutCString(" (unresolved L value reference)"); break;
-        case eRValueReferenceToTypeWithUID: s->PutCString(" (unresolved R value reference)"); break;
+        case eEncodingIsUID: s->PutCString(" (unresolved type)"); break;
+        case eEncodingIsConstUID: s->PutCString(" (unresolved const type)"); break;
+        case eEncodingIsRestrictUID: s->PutCString(" (unresolved restrict type)"); break;
+        case eEncodingIsVolatileUID: s->PutCString(" (unresolved volatile type)"); break;
+        case eEncodingIsTypedefUID: s->PutCString(" (unresolved typedef)"); break;
+        case eEncodingIsPointerUID: s->PutCString(" (unresolved pointer)"); break;
+        case eEncodingIsLValueReferenceUID: s->PutCString(" (unresolved L value reference)"); break;
+        case eEncodingIsRValueReferenceUID: s->PutCString(" (unresolved R value reference)"); break;
+        case eEncodingIsSyntheticUID: s->PutCString(" (synthetic type)"); break;
+        case eEncodingIsTypePtr: s->PutCString(" (Type *)"); break;
         }
     }    
 }
@@ -151,19 +156,21 @@
 
         ClangASTType::DumpTypeDescription (GetClangAST(), m_clang_qual_type, s);
     }
-    else if (m_encoding_uid != LLDB_INVALID_UID)
+    else if (m_encoding_data != LLDB_INVALID_UID)
     {
-        *s << ", type_uid = " << m_encoding_uid;
-        switch (m_encoding_uid_type)
+        *s << ", type_data = " << (uint64_t)m_encoding_data;
+        switch (m_encoding_data_type)
         {
-        case eIsTypeWithUID: s->PutCString(" (unresolved type)"); break;
-        case eIsConstTypeWithUID: s->PutCString(" (unresolved const type)"); break;
-        case eIsRestrictTypeWithUID: s->PutCString(" (unresolved restrict type)"); break;
-        case eIsVolatileTypeWithUID: s->PutCString(" (unresolved volatile type)"); break;
-        case eTypedefToTypeWithUID: s->PutCString(" (unresolved typedef)"); break;
-        case ePointerToTypeWithUID: s->PutCString(" (unresolved pointer)"); break;
-        case eLValueReferenceToTypeWithUID: s->PutCString(" (unresolved L value reference)"); break;
-        case eRValueReferenceToTypeWithUID: s->PutCString(" (unresolved R value reference)"); break;
+        case eEncodingIsUID: s->PutCString(" (unresolved type)"); break;
+        case eEncodingIsConstUID: s->PutCString(" (unresolved const type)"); break;
+        case eEncodingIsRestrictUID: s->PutCString(" (unresolved restrict type)"); break;
+        case eEncodingIsVolatileUID: s->PutCString(" (unresolved volatile type)"); break;
+        case eEncodingIsTypedefUID: s->PutCString(" (unresolved typedef)"); break;
+        case eEncodingIsPointerUID: s->PutCString(" (unresolved pointer)"); break;
+        case eEncodingIsLValueReferenceUID: s->PutCString(" (unresolved L value reference)"); break;
+        case eEncodingIsRValueReferenceUID: s->PutCString(" (unresolved R value reference)"); break;
+        case eEncodingIsSyntheticUID: s->PutCString(" (synthetic type)"); break;
+        case eEncodingIsTypePtr: s->PutCString(" (Type *)"); break;
         }
     }
 
@@ -241,16 +248,16 @@
 {
     if (m_byte_size == 0)
     {
-        switch (m_encoding_uid_type)
+        switch (m_encoding_data_type)
         {
-        case eIsTypeWithUID:
-        case eIsConstTypeWithUID:
-        case eIsRestrictTypeWithUID:
-        case eIsVolatileTypeWithUID:
-        case eTypedefToTypeWithUID:
-            if (m_encoding_uid != LLDB_INVALID_UID)
+        case eEncodingIsUID:
+        case eEncodingIsConstUID:
+        case eEncodingIsRestrictUID:
+        case eEncodingIsVolatileUID:
+        case eEncodingIsTypedefUID:
+            if (m_encoding_data != LLDB_INVALID_UID)
             {
-                Type *encoding_type = m_symbol_file->ResolveTypeUID (m_encoding_uid);
+                Type *encoding_type = m_symbol_file->ResolveTypeUID (m_encoding_data);
                 if (encoding_type)
                     m_byte_size = encoding_type->GetByteSize();
             }
@@ -262,9 +269,9 @@
             break;
 
         // If we are a pointer or reference, then this is just a pointer size;
-        case ePointerToTypeWithUID:
-        case eLValueReferenceToTypeWithUID:
-        case eRValueReferenceToTypeWithUID:
+        case eEncodingIsPointerUID:
+        case eEncodingIsLValueReferenceUID:
+        case eEncodingIsRValueReferenceUID:
             m_byte_size = GetTypeList()->GetClangASTContext().GetPointerBitSize() / 8;
             break;
         }
@@ -400,113 +407,132 @@
 bool
 lldb_private::Type::ResolveClangType (bool forward_decl_is_ok)
 {
+//    static int g_depth = 0;
+//    g_depth++;
+//    printf ("%.*sType::ResolveClangType (forward = %i) uid = 0x%8.8x, name = %s\n", g_depth, "", forward_decl_is_ok, m_uid, m_name.AsCString()); 
+    Type *encoding_type = NULL;
     if (m_clang_qual_type == NULL)
     {
         TypeList *type_list = GetTypeList();
-        if (m_encoding_uid != LLDB_INVALID_UID)
+        if (m_encoding_data != LLDB_INVALID_UID)
         {
-            Type *encoding_type = m_symbol_file->ResolveTypeUID(m_encoding_uid);
+            encoding_type = m_symbol_file->ResolveTypeUID(m_encoding_data);
             if (encoding_type)
             {
-
-                switch (m_encoding_uid_type)
+                switch (m_encoding_data_type)
                 {
-                case eIsTypeWithUID:
+                case eEncodingIsUID:
                     m_clang_qual_type = encoding_type->GetClangType();
                     break;
 
-                case eIsConstTypeWithUID:
-                    m_clang_qual_type = ClangASTContext::AddConstModifier (encoding_type->GetClangType(forward_decl_is_ok));
+                case eEncodingIsConstUID:
+                    m_clang_qual_type = ClangASTContext::AddConstModifier (encoding_type->GetClangType(true));
                     break;
 
-                case eIsRestrictTypeWithUID:
-                    m_clang_qual_type = ClangASTContext::AddRestrictModifier (encoding_type->GetClangType(forward_decl_is_ok));
+                case eEncodingIsRestrictUID:
+                    m_clang_qual_type = ClangASTContext::AddRestrictModifier (encoding_type->GetClangType(true));
                     break;
 
-                case eIsVolatileTypeWithUID:
-                    m_clang_qual_type = ClangASTContext::AddVolatileModifier (encoding_type->GetClangType(forward_decl_is_ok));
+                case eEncodingIsVolatileUID:
+                    m_clang_qual_type = ClangASTContext::AddVolatileModifier (encoding_type->GetClangType(true));
                     break;
 
-                case eTypedefToTypeWithUID:
-                    m_clang_qual_type = type_list->CreateClangTypedefType (this, encoding_type, forward_decl_is_ok);
+                case eEncodingIsTypedefUID:
+                    m_clang_qual_type = type_list->CreateClangTypedefType (this, encoding_type, true);
                     // Clear the name so it can get fully qualified in case the
                     // typedef is in a namespace.
                     m_name.Clear();
                     break;
 
-                case ePointerToTypeWithUID:
-                    m_clang_qual_type = type_list->CreateClangPointerType (encoding_type, forward_decl_is_ok);
+                case eEncodingIsPointerUID:
+                    m_clang_qual_type = type_list->CreateClangPointerType (encoding_type, true);
                     break;
 
-                case eLValueReferenceToTypeWithUID:
-                    m_clang_qual_type = type_list->CreateClangLValueReferenceType (encoding_type, forward_decl_is_ok);
+                case eEncodingIsLValueReferenceUID:
+                    m_clang_qual_type = type_list->CreateClangLValueReferenceType (encoding_type, true);
                     break;
 
-                case eRValueReferenceToTypeWithUID:
-                    m_clang_qual_type = type_list->CreateClangRValueReferenceType (encoding_type, forward_decl_is_ok);
+                case eEncodingIsRValueReferenceUID:
+                    m_clang_qual_type = type_list->CreateClangRValueReferenceType (encoding_type, true);
                     break;
 
                 default:
-                    assert(!"Unhandled encoding_uid_type.");
+                    assert(!"Unhandled encoding_data_type.");
                     break;
                 }
+                
+                if (encoding_type)
+                {
+                    m_encoding_data_type = eEncodingIsTypePtr;
+                    m_encoding_data = (uintptr_t)encoding_type;
+                }
             }
-            // Return here since we won't need to check if this is a forward 
-            // declaration below since we already obeyed this above.
-            return m_clang_qual_type != NULL;
         }
         else
         {
             // We have no encoding type, return void?
             clang_type_t void_clang_type = type_list->GetClangASTContext().GetBuiltInType_void();
-            switch (m_encoding_uid_type)
+            switch (m_encoding_data_type)
             {
-            case eIsTypeWithUID:
+            case eEncodingIsUID:
                 m_clang_qual_type = void_clang_type;
                 break;
 
-            case eIsConstTypeWithUID:
+            case eEncodingIsConstUID:
                 m_clang_qual_type = ClangASTContext::AddConstModifier (void_clang_type);
                 break;
 
-            case eIsRestrictTypeWithUID:
+            case eEncodingIsRestrictUID:
                 m_clang_qual_type = ClangASTContext::AddRestrictModifier (void_clang_type);
                 break;
 
-            case eIsVolatileTypeWithUID:
+            case eEncodingIsVolatileUID:
                 m_clang_qual_type = ClangASTContext::AddVolatileModifier (void_clang_type);
                 break;
 
-            case eTypedefToTypeWithUID:
+            case eEncodingIsTypedefUID:
                 m_clang_qual_type = type_list->GetClangASTContext().CreateTypedefType (m_name.AsCString(), void_clang_type, NULL);
                 break;
 
-            case ePointerToTypeWithUID:
+            case eEncodingIsPointerUID:
                 m_clang_qual_type = type_list->GetClangASTContext().CreatePointerType (void_clang_type);
                 break;
 
-            case eLValueReferenceToTypeWithUID:
+            case eEncodingIsLValueReferenceUID:
                 m_clang_qual_type = type_list->GetClangASTContext().CreateLValueReferenceType (void_clang_type);
                 break;
 
-            case eRValueReferenceToTypeWithUID:
+            case eEncodingIsRValueReferenceUID:
                 m_clang_qual_type = type_list->GetClangASTContext().CreateRValueReferenceType (void_clang_type);
                 break;
 
             default:
-                assert(!"Unhandled encoding_uid_type.");
+                assert(!"Unhandled encoding_data_type.");
                 break;
             }
         }
     }
     
     // Check if we have a forward reference to a class/struct/union/enum?
-    if (!forward_decl_is_ok && !ClangASTType::IsDefined (m_clang_qual_type))
+    if (m_is_forward_decl && m_clang_qual_type && !forward_decl_is_ok)
     {
-        // We have a forward declaration, we need to resolve it to a complete
-        // definition.
-        m_symbol_file->ResolveClangOpaqueTypeDefinition (m_clang_qual_type);
+        m_is_forward_decl = false;
+        if (!ClangASTType::IsDefined (m_clang_qual_type))
+        {
+            // We have a forward declaration, we need to resolve it to a complete
+            // definition.
+            m_symbol_file->ResolveClangOpaqueTypeDefinition (m_clang_qual_type);
+        }
+        else
+        {
+            if (encoding_type == NULL)
+                encoding_type = GetEncodingType ();
+            if (encoding_type != NULL)
+                encoding_type->ResolveClangType (forward_decl_is_ok);
+        }
     }
+//    if (g_depth > 0)
+//        --g_depth;
     return m_clang_qual_type != NULL;
 }