[Symbol] Use llvm::Expected when getting TypeSystems

[xiaobai]

Summary

This commit achieves the following:

• Functions used to return a TypeSystem * return an llvm::Expected<TypeSystem *> now. This means that the result of a call is always checked, forcing clients to move more carefully.
• TypeSystemMap::GetTypeSystemForLanguage will either return an Error or a non-null pointer to a TypeSystem.

[JDevlieghere]

source/Breakpoint/Watchpoint.cpp

45 ↗

(On Diff #211218)

LLDB_LOG(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS), "Watchpoint::Watchpoint(): Failed to set type.\nReason: {}", llvm::toString(type_system_or_err.takeError())

source/Core/ValueObjectRegister.cpp

261 ↗

(On Diff #211218)

As a general note: I think it's good practice to use llvm::consumeError when discarding the error to make it explicit that it's not handled. This also makes it easier down the line to handle the error, e.g. by logging it.

source/Expression/Materializer.cpp

875 ↗

(On Diff #211218)

Another possible alternative would be to join the errors (llvm::joinErrors) and use the resulting error to initialize the status. Not sure if that makes things better here though.

source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp

105 ↗

(On Diff #211218)

Seems like this could be a lot less complex with an early return:

if (!m_cu) {
    return llvm::make_error<llvm::StringError>(
        "Unable to get TypeSystem, no compilation unit available",
        llvm::inconvertibleErrorCode());
}
return m_cu->GetTypeSystem();

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

744 ↗

(On Diff #211218)

Remove the braces for consistency with the ifs below.

[labath]

The intention is for the pointer in Expected<TypeSystem *> to be non-null in the success case, right? If that's true, then I'd suggest to make that explicit by returning a reference (Expected<TypeSystem&>) instead.

source/Core/ValueObjectRegister.cpp

261 ↗

(On Diff #211218)

This is not just good practice, it is actually required. An simply checking the bool-ness of the Expected object will not set the "checked" flag of the error object, and it will assert when it is destroyed (if asserts are enabled).

263 ↗

(On Diff #211218)

If you returned a reference then you also wouldn't need this extra variable to avoid weird double-deref.

[xiaobai]

source/Core/ValueObjectRegister.cpp

261 ↗

(On Diff #211218)

So what you're saying is do not define it in an if condition, but rather get the Expected and if it isn't valid then we consume the error, else use the type system. Is that right?

source/Expression/Materializer.cpp

875 ↗

(On Diff #211218)

I'm not sure either, I'll try it and see what it looks like.

source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp

105 ↗

(On Diff #211218)

Hmm, yeah that looks better.

[labath]

source/Core/ValueObjectRegister.cpp

261 ↗

(On Diff #211218)

Yes, although technically, the value can still be defined in the if-condition, as its scope extends into the else clause. So the following code is perfectly valid (if slightly surprising):

if (auto expected_foo = maybe_get_foo())
  do_stuff(*expected_foo);
else
  log(expected_foo.takeError());

source/Expression/Materializer.cpp

875 ↗

(On Diff #211218)

I'm not a fan of joined errors, and this does not sound like the right place to start using them, as these aren't two separate errors that we've encountered, but rather one error that ends up causing another error to happen. So the best way to model this IMO would be to use nested errors the same way that Java has nested exceptions (but I don't think it's worth doing that here).

[xiaobai]

After going through this and modifying this patch, I can't help but wonder if llvm::Optional<TypeSystem &> would be more appropriate. There are plenty of instances where it's not a hard error if you can't get a TypeSystem and the appropriate action is probably just to log and move on. I am conflicted because I like how Expected forces you to be more rigorous with error handling but I can't help but feel it is the wrong abstraction. Thoughts?

[JDevlieghere]

In D65122#1602025, @xiaobai wrote:

After going through this and modifying this patch, I can't help but wonder if llvm::Optional<TypeSystem &> would be more appropriate. There are plenty of instances where it's not a hard error if you can't get a TypeSystem and the appropriate action is probably just to log and move on. I am conflicted because I like how Expected forces you to be more rigorous with error handling but I can't help but feel it is the wrong abstraction. Thoughts?

I think an Optional would be fine. We can always create an Error when necessary, with the trade-off of being a little less precision about the root cause, which honestly doesn't seem that informative anyway.

[labath]

In D65122#1602067, @JDevlieghere wrote:

In D65122#1602025, @xiaobai wrote:

After going through this and modifying this patch, I can't help but wonder if llvm::Optional<TypeSystem &> would be more appropriate. There are plenty of instances where it's not a hard error if you can't get a TypeSystem and the appropriate action is probably just to log and move on. I am conflicted because I like how Expected forces you to be more rigorous with error handling but I can't help but feel it is the wrong abstraction. Thoughts?

I think an Optional would be fine. We can always create an Error when necessary, with the trade-off of being a little less precision about the root cause, which honestly doesn't seem that informative anyway.

I'm not that familiar with type systems, so I don't know if an explicit error value is useful. Adopting Error/Expected initially has a slightly higher barrier because the surrounding code does not know about Errors, and so you have to do something explicit and verbose to the error, and then create a default value of the return type anyway. But, as the surrounding code adopts Errors, the verboseness should disappear. This, of course, assumes that we want to adopt Errors here and in the surrounding code.

What I am familiar with though is the Optional template, I can note that there is no such thing as an Optional<T&> (the Optional template does not play well with references). You could make that a thing, but an Optional<T&> is essentially just a T *, which is what we have now :D. And I wouldn't want Optional<T*> as that just creates more ambiguity.

Thinking ahead I am wondering if we could just arrange things such that the TypeSystem creation always succeeds. One day, I am hoping to arrange is so that a Module will always have an associated ObjectFile and a SymbolFile (by avoiding creating a Module if the ObjectFile construction fails, and creating an "empty" SymbolFile if needed). At that point being able to always create a type system would not seem unreasonable. I don't think any of this is directly relevant here and now, but it may speak against introducing Expected here (if you agree with my vision, that is).

[jingham]

It seems to me part of the goal of Alex's efforts is to make it possible for a given lldb to have or not have support for any particular type system. In some future day they might even be live pluggable, so that which ones get loaded would be a user choice. In that future, it is never an error to not have a given type system. And even if lldb has builtin code to support a given type system, I may not want to pay the cost to construct it. If I'm debugging ObjC code in a program that also supports swift, I might want to tell lldb not to bother with swift types.

If that seems reasonable, then TypeSystems are really optional, and you should always be prepared for one not to exist. IIUC that's better expressed by Optional than Expected.

[xiaobai]

I'm going to update this diff with what I changed to give y'all a better idea of what has been changed. I shoulda done that to begin with... :P

In D65122#1602145, @labath wrote:

In D65122#1602067, @JDevlieghere wrote:

In D65122#1602025, @xiaobai wrote:

After going through this and modifying this patch, I can't help but wonder if llvm::Optional<TypeSystem &> would be more appropriate. There are plenty of instances where it's not a hard error if you can't get a TypeSystem and the appropriate action is probably just to log and move on. I am conflicted because I like how Expected forces you to be more rigorous with error handling but I can't help but feel it is the wrong abstraction. Thoughts?

I think an Optional would be fine. We can always create an Error when necessary, with the trade-off of being a little less precision about the root cause, which honestly doesn't seem that informative anyway.

I'm not that familiar with type systems, so I don't know if an explicit error value is useful. Adopting Error/Expected initially has a slightly higher barrier because the surrounding code does not know about Errors, and so you have to do something explicit and verbose to the error, and then create a default value of the return type anyway. But, as the surrounding code adopts Errors, the verboseness should disappear. This, of course, assumes that we want to adopt Errors here and in the surrounding code.

What I am familiar with though is the Optional template, I can note that there is no such thing as an Optional<T&> (the Optional template does not play well with references). You could make that a thing, but an Optional<T&> is essentially just a T *, which is what we have now :D. And I wouldn't want Optional<T*> as that just creates more ambiguity.

Thinking ahead I am wondering if we could just arrange things such that the TypeSystem creation always succeeds. One day, I am hoping to arrange is so that a Module will always have an associated ObjectFile and a SymbolFile (by avoiding creating a Module if the ObjectFile construction fails, and creating an "empty" SymbolFile if needed). At that point being able to always create a type system would not seem unreasonable. I don't think any of this is directly relevant here and now, but it may speak against introducing Expected here (if you agree with my vision, that is).

Yeah, switching to an Optional<T&> or Optional<T*> doesn't seem like an actual tangible improvement over what we have now... And an Expected<T&> seems to at least promote better error handling. The initial cost is indeed high though. :P
Eventually having a system such that makes TypeSystem creation always succeed would be much nicer. Though I agree, I think that using an Expected here is better than returning a pointer since TypeSystem creation can fail right now. I don't think it should be too difficult to change back if and when we get to that point.

In D65122#1602853, @jingham wrote:

It seems to me part of the goal of Alex's efforts is to make it possible for a given lldb to have or not have support for any particular type system. In some future day they might even be live pluggable, so that which ones get loaded would be a user choice. In that future, it is never an error to not have a given type system. And even if lldb has builtin code to support a given type system, I may not want to pay the cost to construct it. If I'm debugging ObjC code in a program that also supports swift, I might want to tell lldb not to bother with swift types.

If that seems reasonable, then TypeSystems are really optional, and you should always be prepared for one not to exist. IIUC that's better expressed by Optional than Expected.

Yes, that is definitely a part of my goal. That's why I felt Optional better suited this than Expected... but I also feel that Expected forces people to be more careful.

[xiaobai]

Address comments:

• Use Expected<TypeSystem&>
• Did some formatting
• Made error checking more explicit

[labath]

I have one remark about the consumeError+LLDB_LOG pattern. As for whether this is better than status quo or not, I still don't have an opinion on that. :)

source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

80–84 ↗

(On Diff #212031)

I don't believe this will work. Once you consume the error, it is left in an indeterminate state (which happens to be the "success" state, but it's best not to rely on it).
If you do want to log the error (which I do recommend), then you can use the LLDB_LOG_ERROR macro. This one will clear the error for you, and it will do so even if logging is disabled. I.e., if you log the error, there's no need for an additional consumeError call.

[xiaobai]

Fix incorrect error logging pattern

[xiaobai]

In D65122#1604352, @labath wrote:

I have one remark about the consumeError+LLDB_LOG pattern. As for whether this is better than status quo or not, I still don't have an opinion on that. :)

Thanks for pointing out LLDB_LOG_ERROR. I updated this change so people could have a chance to see what the change would look like so they have something concrete to look at instead of just speculating what it could look like.

[JDevlieghere]

source/API/SBModule.cpp

493 ↗

(On Diff #212210)

No else before return?

525 ↗

(On Diff #212031)

Any reason you do this instead of

if (!type_system_or_err) {
  llvm::consumeError(type_system_or_err.takeError());
...

[xiaobai]

Small logic change in SBModule

[xiaobai]

source/API/SBModule.cpp

525 ↗

(On Diff #212031)

No reason in particular. Is there a benefit in doing so or something I'm misunderstanding?

[JDevlieghere]

source/API/SBModule.cpp

525 ↗

(On Diff #212031)

I like it because it's shorter and a bit easier to read. Probably it doesn't matter. If this works I don't want to hold up your change because of it.

lldb/trunk/include/lldb/Core/Module.h

uint32_t ResolveSymbolContextsForFileSpec(
       const FileSpec &file_spec, uint32_t line, bool check_inlines,
       lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list);
 
   void SetFileSpecAndObjectName(const FileSpec &file,
                                 ConstString object_name);
 
   bool GetIsDynamicLinkEditor();
 
-  TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language);
+  llvm::Expected<TypeSystem &>
+  GetTypeSystemForLanguage(lldb::LanguageType language);
 
   // Special error functions that can do printf style formatting that will
   // prepend the message with something appropriate for this module (like the
   // architecture, path and object name (if any)). This centralizes code so
   // that everyone doesn't need to format their error and log messages on their
   // own and keeps the output a bit more consistent.
   void LogMessage(Log *log, const char *format, ...)
       __attribute__((format(printf, 3, 4)));

lldb/trunk/include/lldb/Symbol/SymbolFile.h

GetMangledNamesForFunction(const std::string &scope_qualified_name,
                              std::vector<ConstString> &mangled_names);
 
   virtual size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                           lldb::TypeClass type_mask,
                           lldb_private::TypeList &type_list) = 0;
 
   virtual void PreloadSymbols();
 
-  virtual lldb_private::TypeSystem *
+  virtual llvm::Expected<lldb_private::TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language);
 
   virtual CompilerDeclContext
   FindNamespace(ConstString name,
                 const CompilerDeclContext *parent_decl_ctx) {
     return CompilerDeclContext();
   }
 

lldb/trunk/include/lldb/Symbol/TypeSystem.h

 
 #include <functional>
 #include <map>
 #include <mutex>
 #include <string>
 
 #include "llvm/ADT/APSInt.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/Error.h"
 
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Expression/Expression.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/lldb-private.h"
 
 class DWARFDIE;
public:
   // Clear calls Finalize on all the TypeSystems managed by this map, and then
   // empties the map.
   void Clear();
 
   // Iterate through all of the type systems that are created. Return true from
   // callback to keep iterating, false to stop iterating.
   void ForEach(std::function<bool(TypeSystem *)> const &callback);
 
-  TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language,
-                                       Module *module, bool can_create);
-
-  TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language,
-                                       Target *target, bool can_create);
+  llvm::Expected<TypeSystem &>
+  GetTypeSystemForLanguage(lldb::LanguageType language, Module *module,
+                           bool can_create);
+
+  llvm::Expected<TypeSystem &>
+  GetTypeSystemForLanguage(lldb::LanguageType language, Target *target,
+                           bool can_create);
 
 protected:
-  // This function does not take the map mutex, and should only be called from
-  // functions that do take the mutex.
-  void AddToMap(lldb::LanguageType language,
-                lldb::TypeSystemSP const &type_system_sp);
-
   typedef std::map<lldb::LanguageType, lldb::TypeSystemSP> collection;
   mutable std::mutex m_mutex; ///< A mutex to keep this object happy in
                               ///multi-threaded environments.
   collection m_map;
   bool m_clear_in_progress;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_TypeSystem_h_

lldb/trunk/include/lldb/Target/Target.h

public:
   lldb::ThreadSP CalculateThread() override;
 
   lldb::StackFrameSP CalculateStackFrame() override;
 
   void CalculateExecutionContext(ExecutionContext &exe_ctx) override;
 
   PathMappingList &GetImageSearchPathList();
 
-  TypeSystem *GetScratchTypeSystemForLanguage(Status *error,
-                                              lldb::LanguageType language,
-                                              bool create_on_demand = true);
+  llvm::Expected<TypeSystem &>
+  GetScratchTypeSystemForLanguage(lldb::LanguageType language,
 
   PersistentExpressionState *
   GetPersistentExpressionStateForLanguage(lldb::LanguageType language);
 
   // Creates a UserExpression for the given language, the rest of the
   // parameters have the same meaning as for the UserExpression constructor.
   // Returns a new-ed object which the caller owns.
 

lldb/trunk/source/API/SBModule.cpp

lldb::SBType SBModule::FindFirstType(const char *name_cstr) {
   if (name_cstr && module_sp) {
     SymbolContext sc;
     const bool exact_match = false;
     ConstString name(name_cstr);
 
     sb_type = SBType(module_sp->FindFirstType(sc, name, exact_match));
 
     if (!sb_type.IsValid()) {
-      TypeSystem *type_system =
+      auto type_system_or_err =
           module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
-      if (type_system)
-        sb_type = SBType(type_system->GetBuiltinTypeByName(name));
+      if (auto err = type_system_or_err.takeError()) {
+        llvm::consumeError(std::move(err));
+        return LLDB_RECORD_RESULT(SBType());
+      }
+      sb_type = SBType(type_system_or_err->GetBuiltinTypeByName(name));
     }
   }
   return LLDB_RECORD_RESULT(sb_type);
 }
 
 lldb::SBType SBModule::GetBasicType(lldb::BasicType type) {
   LLDB_RECORD_METHOD(lldb::SBType, SBModule, GetBasicType, (lldb::BasicType),
                      type);
 
   ModuleSP module_sp(GetSP());
   if (module_sp) {
-    TypeSystem *type_system =
+    auto type_system_or_err =
         module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
-    if (type_system)
-      return LLDB_RECORD_RESULT(SBType(type_system->GetBasicTypeFromAST(type)));
+    if (auto err = type_system_or_err.takeError()) {
+      llvm::consumeError(std::move(err));
+    } else {
+      return LLDB_RECORD_RESULT(
+          SBType(type_system_or_err->GetBasicTypeFromAST(type)));
+    }
   }
   return LLDB_RECORD_RESULT(SBType());
 }
 
 lldb::SBTypeList SBModule::FindTypes(const char *type) {
   LLDB_RECORD_METHOD(lldb::SBTypeList, SBModule, FindTypes, (const char *),
                      type);
 
if (type && module_sp) {
 
     if (num_matches > 0) {
       for (size_t idx = 0; idx < num_matches; idx++) {
         TypeSP type_sp(type_list.GetTypeAtIndex(idx));
         if (type_sp)
           retval.Append(SBType(type_sp));
       }
     } else {
-      TypeSystem *type_system =
+      auto type_system_or_err =
           module_sp->GetTypeSystemForLanguage(eLanguageTypeC);
-      if (type_system) {
-        CompilerType compiler_type = type_system->GetBuiltinTypeByName(name);
+      if (auto err = type_system_or_err.takeError()) {
+        llvm::consumeError(std::move(err));
+      } else {
+        CompilerType compiler_type =
+            type_system_or_err->GetBuiltinTypeByName(name);
         if (compiler_type)
           retval.Append(SBType(compiler_type));
       }
     }
   }
 
   return LLDB_RECORD_RESULT(retval);
 }

lldb/trunk/source/Breakpoint/Watchpoint.cpp

 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Expression/UserExpression.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadSpec.h"
+#include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 Watchpoint::Watchpoint(Target &target, lldb::addr_t addr, uint32_t size,
                        const CompilerType *type, bool hardware)
     : StoppointLocation(0, addr, size, hardware), m_target(target),
       m_enabled(false), m_is_hardware(hardware), m_is_watch_variable(false),
       m_is_ephemeral(false), m_disabled_count(0), m_watch_read(0),
       m_watch_write(0), m_watch_was_read(0), m_watch_was_written(0),
       m_ignore_count(0), m_false_alarms(0), m_decl_str(), m_watch_spec_str(),
       m_type(), m_error(), m_options(), m_being_created(true) {
+
   if (type && type->IsValid())
     m_type = *type;
   else {
     // If we don't have a known type, then we force it to unsigned int of the
     // right size.
-    TypeSystem *ast_context =
-        target.GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC);
-    m_type = ast_context->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint,
-                                                              8 * size);
+    auto type_system_or_err =
+        target.GetScratchTypeSystemForLanguage(eLanguageTypeC);
+    if (auto err = type_system_or_err.takeError()) {
+      LLDB_LOG_ERROR(
+          lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_WATCHPOINTS),
+          std::move(err), "Failed to set type.");
+    } else {
+      m_type = type_system_or_err->GetBuiltinTypeForEncodingAndBitSize(
+          eEncodingUint, 8 * size);
+    }
   }
 
   // Set the initial value of the watched variable:
   if (m_target.GetProcessSP()) {
     ExecutionContext exe_ctx;
     m_target.GetProcessSP()->CalculateExecutionContext(exe_ctx);
     CaptureWatchedValue(exe_ctx);
   }

lldb/trunk/source/Core/Module.cpp

void Module::SetUUID(const lldb_private::UUID &uuid) {
   if (!m_did_set_uuid) {
     m_uuid = uuid;
     m_did_set_uuid = true;
   } else {
     lldbassert(0 && "Attempting to overwrite the existing module UUID");
   }
 }
 
-TypeSystem *Module::GetTypeSystemForLanguage(LanguageType language) {
+llvm::Expected<TypeSystem &>
+Module::GetTypeSystemForLanguage(LanguageType language) {
   return m_type_system_map.GetTypeSystemForLanguage(language, this, true);
 }
 
 void Module::ParseAllDebugSymbols() {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   size_t num_comp_units = GetNumCompileUnits();
   if (num_comp_units == 0)
     return;

lldb/trunk/source/Core/ValueObjectRegister.cpp

 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Log.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 
 #include "llvm/ADT/StringRef.h"
 
 #include <assert.h>
 #include <memory>
ValueObjectRegister::ValueObjectRegister(ExecutionContextScope *exe_scope,
   ConstructObject(reg_num);
 }
 
 ValueObjectRegister::~ValueObjectRegister() {}
 
 CompilerType ValueObjectRegister::GetCompilerTypeImpl() {
   if (!m_compiler_type.IsValid()) {
     ExecutionContext exe_ctx(GetExecutionContextRef());
-    Target *target = exe_ctx.GetTargetPtr();
-    if (target) {
-      Module *exe_module = target->GetExecutableModulePointer();
-      if (exe_module) {
-        TypeSystem *type_system =
+    if (auto *target = exe_ctx.GetTargetPtr()) {
+      if (auto *exe_module = target->GetExecutableModulePointer()) {
+        auto type_system_or_err =
             exe_module->GetTypeSystemForLanguage(eLanguageTypeC);
-        if (type_system)
-          m_compiler_type = type_system->GetBuiltinTypeForEncodingAndBitSize(
+        if (auto err = type_system_or_err.takeError()) {
+          LLDB_LOG_ERROR(
+              lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TYPES),
+              std::move(err), "Unable to get CompilerType from TypeSystem");
+        } else {
+          m_compiler_type =
+              type_system_or_err->GetBuiltinTypeForEncodingAndBitSize(
                   m_reg_info.encoding, m_reg_info.byte_size * 8);
         }
       }
     }
+  }
   return m_compiler_type;
 }
 
 ConstString ValueObjectRegister::GetTypeName() {
   if (m_type_name.IsEmpty())
     m_type_name = GetCompilerType().GetConstTypeName();
   return m_type_name;
 }

lldb/trunk/source/DataFormatters/VectorType.cpp

 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/Target.h"
 
 #include "lldb/Utility/LLDBAssert.h"
+#include "lldb/Utility/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 static CompilerType GetCompilerTypeForFormat(lldb::Format format,
                                              CompilerType element_type,
                                              TypeSystem *type_system) {
lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
     return child_sp;
   }
 
   bool Update() override {
     m_parent_format = m_backend.GetFormat();
     CompilerType parent_type(m_backend.GetCompilerType());
     CompilerType element_type;
     parent_type.IsVectorType(&element_type, nullptr);
-    TargetSP target_sp(m_backend.GetTargetSP());
-    m_child_type = ::GetCompilerTypeForFormat(
-        m_parent_format, element_type,
-        target_sp
-            ? target_sp->GetScratchTypeSystemForLanguage(nullptr,
-                                                         lldb::eLanguageTypeC)
-            : nullptr);
+    TypeSystem *type_system = nullptr;
+    if (auto target_sp = m_backend.GetTargetSP()) {
+      auto type_system_or_err =
+          target_sp->GetScratchTypeSystemForLanguage(lldb::eLanguageTypeC);
+      if (auto err = type_system_or_err.takeError()) {
+        LLDB_LOG_ERROR(
+            lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS),
+            std::move(err), "Unable to update from scratch TypeSystem");
+      } else {
+        type_system = &type_system_or_err.get();
+      }
+    }
+    m_child_type =
+        ::GetCompilerTypeForFormat(m_parent_format, element_type, type_system);
     m_num_children = ::CalculateNumChildren(parent_type, m_child_type);
     m_item_format = GetItemFormatForFormat(m_parent_format, m_child_type);
     return false;
   }
 
   bool MightHaveChildren() override { return true; }
 
   size_t GetIndexOfChildWithName(ConstString name) override {

lldb/trunk/source/Expression/Materializer.cpp

void Dematerialize(lldb::StackFrameSP &frame_sp, IRMemoryMap &map,
 
     lldb::TargetSP target_sp = exe_scope->CalculateTarget();
 
     if (!target_sp) {
       err.SetErrorString("Couldn't dematerialize a result variable: no target");
       return;
     }
 
-    Status type_system_error;
-    TypeSystem *type_system = target_sp->GetScratchTypeSystemForLanguage(
-        &type_system_error, m_type.GetMinimumLanguage());
+    auto type_system_or_err =
+        target_sp->GetScratchTypeSystemForLanguage(m_type.GetMinimumLanguage());
 
-    if (!type_system) {
+    if (auto error = type_system_or_err.takeError()) {
       err.SetErrorStringWithFormat("Couldn't dematerialize a result variable: "
                                    "couldn't get the corresponding type "
                                    "system: %s",
-                                   type_system_error.AsCString());
+                                   llvm::toString(std::move(error)).c_str());
       return;
     }
-
     PersistentExpressionState *persistent_state =
-        type_system->GetPersistentExpressionState();
+        type_system_or_err->GetPersistentExpressionState();
 
     if (!persistent_state) {
       err.SetErrorString("Couldn't dematerialize a result variable: "
                          "corresponding type system doesn't handle persistent "
                          "variables");
       return;
     }
 

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

if (m_target->GetUseModernTypeLookup()) {
     // persistent AST context as well as the modules and Objective-C runtime
     // AST contexts.
 
     lldbassert(!m_merger_up);
     clang::ExternalASTMerger::ImporterTarget target = {ast_context,
                                                        file_manager};
     std::vector<clang::ExternalASTMerger::ImporterSource> sources;
     for (lldb::ModuleSP module_sp : m_target->GetImages().Modules()) {
-      if (auto *module_ast_ctx = llvm::cast_or_null<ClangASTContext>(
-              module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeC))) {
+      auto type_system_or_err =
+          module_sp->GetTypeSystemForLanguage(lldb::eLanguageTypeC);
+      if (auto err = type_system_or_err.takeError()) {
+        LLDB_LOG_ERROR(
+            lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS),
+            std::move(err), "Failed to get ClangASTContext");
+      } else if (auto *module_ast_ctx = llvm::cast_or_null<ClangASTContext>(
+                     &type_system_or_err.get())) {
         lldbassert(module_ast_ctx->getASTContext());
         lldbassert(module_ast_ctx->getFileManager());
         sources.push_back({*module_ast_ctx->getASTContext(),
                            *module_ast_ctx->getFileManager(),
-                           module_ast_ctx->GetOriginMap()
-        });
+                           module_ast_ctx->GetOriginMap()});
       }
     }
 
     do {
       lldb::ProcessSP process(m_target->GetProcessSP());
 
       if (!process)
         break;

lldb/trunk/source/Plugins/Language/CPlusPlus/BlockPointer.cpp

 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/Target.h"
 
 #include "lldb/Utility/LLDBAssert.h"
+#include "lldb/Utility/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 namespace lldb_private {
 namespace formatters {
 
 class BlockPointerSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
 public:
   BlockPointerSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
       : SyntheticChildrenFrontEnd(*valobj_sp), m_block_struct_type() {
     CompilerType block_pointer_type(m_backend.GetCompilerType());
     CompilerType function_pointer_type;
     block_pointer_type.IsBlockPointerType(&function_pointer_type);
 
     TargetSP target_sp(m_backend.GetTargetSP());
 
     if (!target_sp) {
       return;
     }
 
-    Status err;
-    TypeSystem *type_system = target_sp->GetScratchTypeSystemForLanguage(
-        &err, lldb::eLanguageTypeC_plus_plus);
-
-    if (!err.Success() || !type_system) {
+    auto type_system_or_err = target_sp->GetScratchTypeSystemForLanguage(
+        lldb::eLanguageTypeC_plus_plus);
+    if (auto err = type_system_or_err.takeError()) {
+      LLDB_LOG_ERROR(
+          lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS),
+          std::move(err), "Failed to get scratch ClangASTContext");
       return;
     }
 
     ClangASTContext *clang_ast_context =
-        llvm::dyn_cast<ClangASTContext>(type_system);
+        llvm::dyn_cast<ClangASTContext>(&type_system_or_err.get());
 
     if (!clang_ast_context) {
       return;
     }
 
     ClangASTImporterSP clang_ast_importer = target_sp->GetClangASTImporter();
 
     if (!clang_ast_importer) {

lldb/trunk/source/Plugins/Language/ObjC/CoreMedia.cpp

 //===-- CoreMedia.cpp --------------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "CoreMedia.h"
 
 #include "lldb/Utility/Flags.h"
+#include "lldb/Utility/Log.h"
 
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Target/Target.h"
 #include <inttypes.h>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 bool lldb_private::formatters::CMTimeSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   CompilerType type = valobj.GetCompilerType();
   if (!type.IsValid())
     return false;
 
-  TypeSystem *type_system =
+  auto type_system_or_err =
       valobj.GetExecutionContextRef()
           .GetTargetSP()
-          ->GetScratchTypeSystemForLanguage(nullptr, lldb::eLanguageTypeC);
-  if (!type_system)
+          ->GetScratchTypeSystemForLanguage(lldb::eLanguageTypeC);
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(
+        lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS),
+        std::move(err), "Failed to get scratch type system");
     return false;
-
+  }
   // fetch children by offset to compensate for potential lack of debug info
-  auto int64_ty =
-      type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 64);
-  auto int32_ty =
-      type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 32);
+  auto int64_ty = type_system_or_err->GetBuiltinTypeForEncodingAndBitSize(
+      eEncodingSint, 64);
+  auto int32_ty = type_system_or_err->GetBuiltinTypeForEncodingAndBitSize(
+      eEncodingSint, 32);
 
   auto value_sp(valobj.GetSyntheticChildAtOffset(0, int64_ty, true));
   auto timescale_sp(valobj.GetSyntheticChildAtOffset(8, int32_ty, true));
   auto flags_sp(valobj.GetSyntheticChildAtOffset(12, int32_ty, true));
 
   if (!value_sp || !timescale_sp || !flags_sp)
     return false;
 

lldb/trunk/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.h

uint32_t FindTypes(ConstString name,
                      const CompilerDeclContext *parent_decl_ctx, bool append,
                      uint32_t max_matches,
                      llvm::DenseSet<SymbolFile *> &searched_symbol_files,
                      TypeMap &types) override;
 
   size_t FindTypes(const std::vector<CompilerContext> &context, bool append,
                    TypeMap &types) override;
 
-  TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language) override {
-    return nullptr;
+  llvm::Expected<TypeSystem &>
+  GetTypeSystemForLanguage(lldb::LanguageType language) override {
+    return llvm::make_error<llvm::StringError>(
+        "SymbolFileBreakpad does not support GetTypeSystemForLanguage",
+        llvm::inconvertibleErrorCode());
   }
 
   CompilerDeclContext
   FindNamespace(ConstString name,
                 const CompilerDeclContext *parent_decl_ctx) override {
     return CompilerDeclContext();
   }
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.h

 //===-- DWARFBaseDIE.h -----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFBaseDIE_h_
 #define SymbolFileDWARF_DWARFBaseDIE_h_
 
 #include "lldb/Core/dwarf.h"
 #include "lldb/lldb-types.h"
 
+#include "llvm/Support/Error.h"
+
 class DIERef;
 class DWARFASTParser;
 class DWARFAttributes;
 class DWARFUnit;
 class DWARFDebugInfoEntry;
 class DWARFDeclContext;
 class SymbolFileDWARF;
 
public:
   SymbolFileDWARF *GetDWARF() const;
 
   DWARFUnit *GetCU() const { return m_cu; }
 
   DWARFDebugInfoEntry *GetDIE() const { return m_die; }
 
   llvm::Optional<DIERef> GetDIERef() const;
 
-  lldb_private::TypeSystem *GetTypeSystem() const;
+  llvm::Expected<lldb_private::TypeSystem &> GetTypeSystem() const;
 
   DWARFASTParser *GetDWARFParser() const;
 
   void Set(DWARFUnit *cu, DWARFDebugInfoEntry *die) {
     if (cu && die) {
       m_cu = cu;
       m_die = die;
     } else {

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFBaseDIE.cpp

 //===-- DWARFBaseDIE.cpp ---------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFBaseDIE.h"
 
 #include "DWARFUnit.h"
 #include "DWARFDebugInfoEntry.h"
 #include "SymbolFileDWARF.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/ObjectFile.h"
+#include "lldb/Utility/Log.h"
 
 using namespace lldb_private;
 
 llvm::Optional<DIERef> DWARFBaseDIE::GetDIERef() const {
   if (!IsValid())
     return llvm::None;
 
   return DIERef(m_cu->GetSymbolFileDWARF().GetDwoNum(), m_cu->GetDebugSection(),

 
 SymbolFileDWARF *DWARFBaseDIE::GetDWARF() const {
   if (m_cu)
     return &m_cu->GetSymbolFileDWARF();
   else
     return nullptr;
 }
 
-lldb_private::TypeSystem *DWARFBaseDIE::GetTypeSystem() const {
-  if (m_cu)
-    return m_cu->GetTypeSystem();
-  else
-    return nullptr;
+llvm::Expected<lldb_private::TypeSystem &> DWARFBaseDIE::GetTypeSystem() const {
+  if (!m_cu)
+    return llvm::make_error<llvm::StringError>(
+        "Unable to get TypeSystem, no compilation unit available",
+        llvm::inconvertibleErrorCode());
 }
 
 DWARFASTParser *DWARFBaseDIE::GetDWARFParser() const {
-  lldb_private::TypeSystem *type_system = GetTypeSystem();
-  if (type_system)
-    return type_system->GetDWARFParser();
-  else
+  auto type_system_or_err = GetTypeSystem();
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+                   std::move(err), "Unable to get DWARFASTParser");
     return nullptr;
   }
+  return type_system_or_err->GetDWARFParser();
+}
 
 bool DWARFBaseDIE::HasChildren() const {
   return m_die && m_die->HasChildren();
 }
 
 bool DWARFBaseDIE::Supports_DW_AT_APPLE_objc_complete_type() const {
   return IsValid() && GetDWARF()->Supports_DW_AT_APPLE_objc_complete_type(m_cu);
 }

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFUnit.h

public:
   dw_addr_t GetStrOffsetsBase() const { return m_str_offsets_base; }
   void SetAddrBase(dw_addr_t addr_base);
   void SetRangesBase(dw_addr_t ranges_base);
   void SetStrOffsetsBase(dw_offset_t str_offsets_base);
   virtual void BuildAddressRangeTable(DWARFDebugAranges *debug_aranges) = 0;
 
   lldb::ByteOrder GetByteOrder() const;
 
-  lldb_private::TypeSystem *GetTypeSystem();
+  llvm::Expected<lldb_private::TypeSystem &> GetTypeSystem();
 
   const DWARFDebugAranges &GetFunctionAranges();
 
   void SetBaseAddress(dw_addr_t base_addr);
 
   DWARFBaseDIE GetUnitDIEOnly() { return DWARFDIE(this, GetUnitDIEPtrOnly()); }
 
   DWARFDIE DIE() { return DWARFDIE(this, DIEPtr()); }

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

void DWARFUnit::ClearDIEsRWLocked() {
   if (m_dwo_symbol_file)
     m_dwo_symbol_file->GetCompileUnit()->ClearDIEsRWLocked();
 }
 
 lldb::ByteOrder DWARFUnit::GetByteOrder() const {
   return m_dwarf.GetObjectFile()->GetByteOrder();
 }
 
-TypeSystem *DWARFUnit::GetTypeSystem() {
+llvm::Expected<TypeSystem &> DWARFUnit::GetTypeSystem() {
   return m_dwarf.GetTypeSystemForLanguage(GetLanguageType());
 }
 
 void DWARFUnit::SetBaseAddress(dw_addr_t base_addr) { m_base_addr = base_addr; }
 
 // Compare function DWARFDebugAranges::Range structures
 static bool CompareDIEOffset(const DWARFDebugInfoEntry &die,
                              const dw_offset_t die_offset) {

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

public:
 
   size_t FindTypes(const std::vector<lldb_private::CompilerContext> &context,
                    bool append, lldb_private::TypeMap &types) override;
 
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                   lldb::TypeClass type_mask,
                   lldb_private::TypeList &type_list) override;
 
-  lldb_private::TypeSystem *
+  llvm::Expected<lldb_private::TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   lldb_private::CompilerDeclContext FindNamespace(
       lldb_private::ConstString name,
       const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
 
   void PreloadSymbols() override;
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 UniqueDWARFASTTypeMap &SymbolFileDWARF::GetUniqueDWARFASTTypeMap() {
   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
   if (debug_map_symfile)
     return debug_map_symfile->GetUniqueDWARFASTTypeMap();
   else
     return m_unique_ast_type_map;
 }
 
-TypeSystem *SymbolFileDWARF::GetTypeSystemForLanguage(LanguageType language) {
-  SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
-  TypeSystem *type_system;
-  if (debug_map_symfile) {
-    type_system = debug_map_symfile->GetTypeSystemForLanguage(language);
-  } else {
-    type_system = m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
-    if (type_system)
-      type_system->SetSymbolFile(this);
+llvm::Expected<TypeSystem &>
+SymbolFileDWARF::GetTypeSystemForLanguage(LanguageType language) {
+  if (SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile())
+    return debug_map_symfile->GetTypeSystemForLanguage(language);
+
+  auto type_system_or_err =
+      m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
+  if (type_system_or_err) {
+    type_system_or_err->SetSymbolFile(this);
   }
-  return type_system;
+  return type_system_or_err;
 }
 
 void SymbolFileDWARF::InitializeObject() {
   Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
 
   if (!GetGlobalPluginProperties()->IgnoreFileIndexes()) {
     DWARFDataExtractor apple_names, apple_namespaces, apple_types, apple_objc;
     LoadSectionData(eSectionTypeDWARFAppleNames, apple_names);
if (auto *dwarf_cu = llvm::cast_or_null<DWARFCompileUnit>(
       return ParseCompileUnit(*dwarf_cu);
   }
   return {};
 }
 
 Function *SymbolFileDWARF::ParseFunction(CompileUnit &comp_unit,
                                          const DWARFDIE &die) {
   ASSERT_MODULE_LOCK(this);
-  if (die.IsValid()) {
-    TypeSystem *type_system =
-        GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());
+  if (!die.IsValid())
+    return nullptr;
 
-    if (type_system) {
-      DWARFASTParser *dwarf_ast = type_system->GetDWARFParser();
-      if (dwarf_ast)
-        return dwarf_ast->ParseFunctionFromDWARF(comp_unit, die);
-    }
+  auto type_system_or_err =
+      GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+                   std::move(err), "Unable to parse function");
+    return nullptr;
   }
+  DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser();
+  if (!dwarf_ast)
     return nullptr;
+
+  return dwarf_ast->ParseFunctionFromDWARF(comp_unit, die);
 }
 
 bool SymbolFileDWARF::FixupAddress(Address &addr) {
   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
   if (debug_map_symfile) {
     return debug_map_symfile->LinkOSOAddress(addr);
   }
   // This is a normal DWARF file, no address fixups need to happen
for (DWARFDIE die = parent_die.GetFirstChild(); die;
           return true;
       }
     }
   }
   return false;
 }
 
 void SymbolFileDWARF::ParseDeclsForContext(CompilerDeclContext decl_ctx) {
-  TypeSystem *type_system = decl_ctx.GetTypeSystem();
+  auto *type_system = decl_ctx.GetTypeSystem();
+  if (!type_system)
+    return;
   DWARFASTParser *ast_parser = type_system->GetDWARFParser();
   std::vector<DWARFDIE> decl_ctx_die_list =
       ast_parser->GetDIEForDeclContext(decl_ctx);
 
   for (DWARFDIE decl_ctx_die : decl_ctx_die_list)
     for (DWARFDIE decl = decl_ctx_die.GetFirstChild(); decl;
          decl = decl.GetSibling())
       ast_parser->GetDeclForUIDFromDWARF(decl);
bool SymbolFileDWARF::DeclContextMatchesThisSymbolFile(
   if (decl_ctx == nullptr || !decl_ctx->IsValid()) {
     // Invalid namespace decl which means we aren't matching only things in
     // this symbol file, so return true to indicate it matches this symbol
     // file.
     return true;
   }
 
   TypeSystem *decl_ctx_type_system = decl_ctx->GetTypeSystem();
-  TypeSystem *type_system = GetTypeSystemForLanguage(
+  auto type_system_or_err = GetTypeSystemForLanguage(
       decl_ctx_type_system->GetMinimumLanguage(nullptr));
-  if (decl_ctx_type_system == type_system)
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+                   std::move(err),
+                   "Unable to match namespace decl using TypeSystem");
+    return false;
+  }
+
+  if (decl_ctx_type_system == &type_system_or_err.get())
     return true; // The type systems match, return true
 
   // The namespace AST was valid, and it does not match...
   Log *log(LogChannelDWARF::GetLogIfAll(DWARF_LOG_LOOKUPS));
 
   if (log)
     GetObjectFile()->GetModule()->LogMessage(
         log, "Valid namespace does not match symbol file");
if (type_name) {
       DIEArray die_offsets;
       m_index->GetTypes(dwarf_decl_ctx, die_offsets);
       const size_t num_matches = die_offsets.size();
 
       // Get the type system that we are looking to find a type for. We will
       // use this to ensure any matches we find are in a language that this
       // type system supports
       const LanguageType language = dwarf_decl_ctx.GetLanguage();
-      TypeSystem *type_system = (language == eLanguageTypeUnknown)
-                                    ? nullptr
-                                    : GetTypeSystemForLanguage(language);
-
+      TypeSystem *type_system = nullptr;
+      if (language != eLanguageTypeUnknown) {
+        auto type_system_or_err = GetTypeSystemForLanguage(language);
+        if (auto err = type_system_or_err.takeError()) {
+          LLDB_LOG_ERROR(
+              lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+              std::move(err), "Cannot get TypeSystem for language {}",
+              Language::GetNameForLanguageType(language));
+        } else {
+          type_system = &type_system_or_err.get();
+        }
+      }
       if (num_matches) {
         for (size_t i = 0; i < num_matches; ++i) {
           const DIERef &die_ref = die_offsets[i];
           DWARFDIE type_die = GetDIE(die_ref);
 
           if (type_die) {
             // Make sure type_die's langauge matches the type system we are
             // looking for. We don't want to find a "Foo" type from Java if we
TypeSP SymbolFileDWARF::FindDefinitionTypeForDWARFDeclContext(
   return type_sp;
 }
 
 TypeSP SymbolFileDWARF::ParseType(const SymbolContext &sc, const DWARFDIE &die,
                                   bool *type_is_new_ptr) {
   if (!die)
     return {};
 
-  TypeSystem *type_system =
+  auto type_system_or_err =
       GetTypeSystemForLanguage(die.GetCU()->GetLanguageType());
-  if (!type_system)
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+                   std::move(err), "Unable to parse type");
     return {};
+  }
 
-  DWARFASTParser *dwarf_ast = type_system->GetDWARFParser();
+  DWARFASTParser *dwarf_ast = type_system_or_err->GetDWARFParser();
   if (!dwarf_ast)
     return {};
 
   Log *log = LogChannelDWARF::GetLogIfAll(DWARF_LOG_DEBUG_INFO);
   TypeSP type_sp = dwarf_ast->ParseTypeFromDWARF(sc, die, log, type_is_new_ptr);
   if (type_sp) {
     GetTypeList().Insert(type_sp);
 

 uint32_t SymbolFileDWARF::GetPluginVersion() { return 1; }
 
 void SymbolFileDWARF::Dump(lldb_private::Stream &s) {
   SymbolFile::Dump(s);
   m_index->Dump(s);
 }
 
 void SymbolFileDWARF::DumpClangAST(Stream &s) {
-  TypeSystem *ts = GetTypeSystemForLanguage(eLanguageTypeC_plus_plus);
-  ClangASTContext *clang = llvm::dyn_cast_or_null<ClangASTContext>(ts);
+  auto ts_or_err = GetTypeSystemForLanguage(eLanguageTypeC_plus_plus);
+  if (!ts_or_err)
+    return;
+  ClangASTContext *clang = llvm::dyn_cast_or_null<ClangASTContext>(&ts_or_err.get());
   if (!clang)
     return;
   clang->Dump(s);
 }
 
 SymbolFileDWARFDebugMap *SymbolFileDWARF::GetDebugMapSymfile() {
   if (m_debug_map_symfile == nullptr && !m_debug_map_module_wp.expired()) {
     lldb::ModuleSP module_sp(m_debug_map_module_wp.lock());

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.h

public:
   GetDWARFCompileUnit(lldb_private::CompileUnit *comp_unit) override;
 
   lldb_private::DWARFExpression::LocationListFormat
   GetLocationListFormat() const override;
 
   size_t GetObjCMethodDIEOffsets(lldb_private::ConstString class_name,
                                  DIEArray &method_die_offsets) override;
 
-  lldb_private::TypeSystem *
+  llvm::Expected<lldb_private::TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   DWARFDIE
   GetDIE(const DIERef &die_ref) override;
 
   std::unique_ptr<SymbolFileDWARFDwo>
   GetDwoSymbolFileForCompileUnit(DWARFUnit &dwarf_cu,
                                  const DWARFDebugInfoEntry &cu_die) override {

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDwo.cpp

SymbolFileDWARF &SymbolFileDWARFDwo::GetBaseSymbolFile() {
   return m_base_dwarf_cu.GetSymbolFileDWARF();
 }
 
 DWARFExpression::LocationListFormat
 SymbolFileDWARFDwo::GetLocationListFormat() const {
   return DWARFExpression::SplitDwarfLocationList;
 }
 
-TypeSystem *
+llvm::Expected<TypeSystem &>
 SymbolFileDWARFDwo::GetTypeSystemForLanguage(LanguageType language) {
   return GetBaseSymbolFile().GetTypeSystemForLanguage(language);
 }
 
 DWARFDIE
 SymbolFileDWARFDwo::GetDIE(const DIERef &die_ref) {
   if (*die_ref.dwo_num() == GetDwoNum())
     return DebugInfo()->GetDIE(die_ref);
   return GetBaseSymbolFile().GetDIE(die_ref);
 }

lldb/trunk/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.h

DeclStatus(lldb::user_id_t uid, bool resolved)
       : uid(uid), resolved(resolved) {}
   lldb::user_id_t uid = 0;
   bool resolved = false;
 };
 
 class PdbAstBuilder {
 public:
   // Constructors and Destructors
-  PdbAstBuilder(ObjectFile &obj, PdbIndex &index);
+  PdbAstBuilder(ObjectFile &obj, PdbIndex &index, ClangASTContext &clang);
 
   lldb_private::CompilerDeclContext GetTranslationUnitDecl();
 
   llvm::Optional<lldb_private::CompilerDecl>
   GetOrCreateDeclForUid(PdbSymUid uid);
   clang::DeclContext *GetOrCreateDeclContextForUid(PdbSymUid uid);
   clang::DeclContext *GetParentDeclContext(PdbSymUid uid);
 

lldb/trunk/source/Plugins/SymbolFile/NativePDB/PdbAstBuilder.cpp

AnyScopesHaveTemplateParams(llvm::ArrayRef<llvm::ms_demangle::Node *> scopes) {
   for (llvm::ms_demangle::Node *n : scopes) {
     auto *idn = static_cast<llvm::ms_demangle::IdentifierNode *>(n);
     if (idn->TemplateParams)
       return true;
   }
   return false;
 }
 
-static ClangASTContext &GetClangASTContext(ObjectFile &obj) {
-  TypeSystem *ts =
-      obj.GetModule()->GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
-  lldbassert(ts);
-  return static_cast<ClangASTContext &>(*ts);
-}
-
 static llvm::Optional<clang::CallingConv>
 TranslateCallingConvention(llvm::codeview::CallingConvention conv) {
   using CC = llvm::codeview::CallingConvention;
   switch (conv) {
 
   case CC::NearC:
   case CC::FarC:
     return clang::CallingConv::CC_C;
GetNestedTagDefinition(const NestedTypeRecord &Record,
 
   return std::move(child);
 }
 
 static bool IsAnonymousNamespaceName(llvm::StringRef name) {
   return name == "`anonymous namespace'" || name == "`anonymous-namespace'";
 }
 
-PdbAstBuilder::PdbAstBuilder(ObjectFile &obj, PdbIndex &index)
-    : m_index(index), m_clang(GetClangASTContext(obj)) {
+PdbAstBuilder::PdbAstBuilder(ObjectFile &obj, PdbIndex &index, ClangASTContext &clang)
+    : m_index(index), m_clang(clang) {
   BuildParentMap();
 }
 
 lldb_private::CompilerDeclContext PdbAstBuilder::GetTranslationUnitDecl() {
   return ToCompilerDeclContext(*m_clang.GetTranslationUnitDecl());
 }
 
 std::pair<clang::DeclContext *, std::string>

lldb/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.h

uint32_t FindTypes(ConstString name,
                      const CompilerDeclContext *parent_decl_ctx, bool append,
                      uint32_t max_matches,
                      llvm::DenseSet<SymbolFile *> &searched_symbol_files,
                      TypeMap &types) override;
 
   size_t FindTypes(const std::vector<CompilerContext> &context, bool append,
                    TypeMap &types) override;
 
-  TypeSystem *GetTypeSystemForLanguage(lldb::LanguageType language) override;
+  llvm::Expected<TypeSystem &>
+  GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   CompilerDeclContext
   FindNamespace(ConstString name,
                 const CompilerDeclContext *parent_decl_ctx) override;
 
   ConstString GetPluginName() override;
 
   uint32_t GetPluginVersion() override;

lldb/trunk/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

 #include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
+#include "lldb/Utility/Log.h"
 
 #include "llvm/DebugInfo/CodeView/CVRecord.h"
 #include "llvm/DebugInfo/CodeView/CVTypeVisitor.h"
 #include "llvm/DebugInfo/CodeView/DebugLinesSubsection.h"
 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
 #include "llvm/DebugInfo/CodeView/RecordName.h"
 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
 #include "llvm/DebugInfo/CodeView/SymbolRecordHelpers.h"
uint32_t SymbolFileNativePDB::CalculateAbilities() {
   return abilities;
 }
 
 void SymbolFileNativePDB::InitializeObject() {
   m_obj_load_address = m_obj_file->GetBaseAddress().GetFileAddress();
   m_index->SetLoadAddress(m_obj_load_address);
   m_index->ParseSectionContribs();
 
-  TypeSystem *ts = m_obj_file->GetModule()->GetTypeSystemForLanguage(
+  auto ts_or_err = m_obj_file->GetModule()->GetTypeSystemForLanguage(
       lldb::eLanguageTypeC_plus_plus);
-  if (ts)
-    ts->SetSymbolFile(this);
-
-  m_ast = llvm::make_unique<PdbAstBuilder>(*m_obj_file, *m_index);
+  if (auto err = ts_or_err.takeError()) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+                   std::move(err), "Failed to initialize");
+  } else {
+    ts_or_err->SetSymbolFile(this);
+    auto *clang = llvm::cast_or_null<ClangASTContext>(&ts_or_err.get());
+    lldbassert(clang);
+    m_ast = llvm::make_unique<PdbAstBuilder>(*m_obj_file, *m_index, *clang);
+  }
 }
 
 uint32_t SymbolFileNativePDB::CalculateNumCompileUnits() {
   const DbiModuleList &modules = m_index->dbi().modules();
   uint32_t count = modules.getModuleCount();
   if (count == 0)
     return count;
 

 }
 
 CompilerDeclContext
 SymbolFileNativePDB::FindNamespace(ConstString name,
                                    const CompilerDeclContext *parent_decl_ctx) {
   return {};
 }
 
-TypeSystem *
+llvm::Expected<TypeSystem &>
 SymbolFileNativePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
-  auto type_system =
+  auto type_system_or_err =
       m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
-  if (type_system)
-    type_system->SetSymbolFile(this);
-  return type_system;
+  if (type_system_or_err) {
+    type_system_or_err->SetSymbolFile(this);
+  }
+  return type_system_or_err;
 }
 
 ConstString SymbolFileNativePDB::GetPluginName() {
   static ConstString g_name("pdb");
   return g_name;
 }
 
 uint32_t SymbolFileNativePDB::GetPluginVersion() { return 1; }

lldb/trunk/source/Plugins/SymbolFile/PDB/SymbolFilePDB.h

public:
 
   void FindTypesByRegex(const lldb_private::RegularExpression &regex,
                         uint32_t max_matches, lldb_private::TypeMap &types);
 
   size_t GetTypes(lldb_private::SymbolContextScope *sc_scope,
                   lldb::TypeClass type_mask,
                   lldb_private::TypeList &type_list) override;
 
-  lldb_private::TypeSystem *
+  llvm::Expected<lldb_private::TypeSystem &>
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   lldb_private::CompilerDeclContext FindNamespace(
       lldb_private::ConstString name,
       const lldb_private::CompilerDeclContext *parent_decl_ctx) override;
 
   lldb_private::ConstString GetPluginName() override;
 

lldb/trunk/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/Variable.h"
+#include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegularExpression.h"
 
 #include "llvm/DebugInfo/PDB/GenericError.h"
 #include "llvm/DebugInfo/PDB/IPDBDataStream.h"
 #include "llvm/DebugInfo/PDB/IPDBEnumChildren.h"
 #include "llvm/DebugInfo/PDB/IPDBLineNumber.h"
 #include "llvm/DebugInfo/PDB/IPDBSectionContrib.h"
 #include "llvm/DebugInfo/PDB/IPDBSourceFile.h"
SymbolFilePDB::ParseCompileUnitFunctionForPDBFunc(const PDBSymbolFunc &pdb_func,
 
   FunctionSP func_sp =
       std::make_shared<Function>(&comp_unit, pdb_func.getSymIndexId(),
                                  func_type_uid, mangled, func_type, func_range);
 
   comp_unit.AddFunction(func_sp);
 
   LanguageType lang = ParseLanguage(comp_unit);
-  TypeSystem *type_system = GetTypeSystemForLanguage(lang);
-  if (!type_system)
+  auto type_system_or_err = GetTypeSystemForLanguage(lang);
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+                   std::move(err), "Unable to parse PDBFunc");
     return nullptr;
+  }
+
   ClangASTContext *clang_type_system =
-    llvm::dyn_cast_or_null<ClangASTContext>(type_system);
+    llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
   if (!clang_type_system)
     return nullptr;
   clang_type_system->GetPDBParser()->GetDeclForSymbol(pdb_func);
 
   return func_sp.get();
 }
 
 size_t SymbolFilePDB::ParseFunctions(CompileUnit &comp_unit) {

 }
 
 lldb_private::Type *SymbolFilePDB::ResolveTypeUID(lldb::user_id_t type_uid) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   auto find_result = m_types.find(type_uid);
   if (find_result != m_types.end())
     return find_result->second.get();
 
-  TypeSystem *type_system =
+  auto type_system_or_err =
       GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+                   std::move(err), "Unable to ResolveTypeUID");
+    return nullptr;
+  }
+
   ClangASTContext *clang_type_system =
-      llvm::dyn_cast_or_null<ClangASTContext>(type_system);
+      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
   if (!clang_type_system)
     return nullptr;
   PDBASTParser *pdb = clang_type_system->GetPDBParser();
   if (!pdb)
     return nullptr;
 
   auto pdb_type = m_session_up->getSymbolById(type_uid);
   if (pdb_type == nullptr)
llvm::Optional<SymbolFile::ArrayInfo> SymbolFilePDB::GetDynamicArrayInfoForUID(
     lldb::user_id_t type_uid, const lldb_private::ExecutionContext *exe_ctx) {
   return llvm::None;
 }
 
 bool SymbolFilePDB::CompleteType(lldb_private::CompilerType &compiler_type) {
   std::lock_guard<std::recursive_mutex> guard(
       GetObjectFile()->GetModule()->GetMutex());
 
-  ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(
-      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus));
+  auto type_system_or_err =
+      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+                   std::move(err), "Unable to get dynamic array info for UID");
+    return false;
+  }
+
+  ClangASTContext *clang_ast_ctx =
+      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
+
   if (!clang_ast_ctx)
     return false;
 
   PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
   if (!pdb)
     return false;
 
   return pdb->CompleteTypeFromPDB(compiler_type);
 }
 
 lldb_private::CompilerDecl SymbolFilePDB::GetDeclForUID(lldb::user_id_t uid) {
-  ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(
-      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus));
+  auto type_system_or_err =
+      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+                   std::move(err), "Unable to get decl for UID");
+    return CompilerDecl();
+  }
+
+  ClangASTContext *clang_ast_ctx =
+      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
   if (!clang_ast_ctx)
     return CompilerDecl();
 
   PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
   if (!pdb)
     return CompilerDecl();
 
   auto symbol = m_session_up->getSymbolById(uid);
   if (!symbol)
     return CompilerDecl();
 
   auto decl = pdb->GetDeclForSymbol(*symbol);
   if (!decl)
     return CompilerDecl();
 
   return CompilerDecl(clang_ast_ctx, decl);
 }
 
 lldb_private::CompilerDeclContext
 SymbolFilePDB::GetDeclContextForUID(lldb::user_id_t uid) {
-  ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(
-      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus));
+  auto type_system_or_err =
+      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+                   std::move(err), "Unable to get DeclContext for UID");
+    return CompilerDeclContext();
+  }
+
+  ClangASTContext *clang_ast_ctx =
+      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
   if (!clang_ast_ctx)
     return CompilerDeclContext();
 
   PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
   if (!pdb)
     return CompilerDeclContext();
 
   auto symbol = m_session_up->getSymbolById(uid);
   if (!symbol)
     return CompilerDeclContext();
 
   auto decl_context = pdb->GetDeclContextForSymbol(*symbol);
   if (!decl_context)
     return GetDeclContextContainingUID(uid);
 
   return CompilerDeclContext(clang_ast_ctx, decl_context);
 }
 
 lldb_private::CompilerDeclContext
 SymbolFilePDB::GetDeclContextContainingUID(lldb::user_id_t uid) {
-  ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(
-      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus));
+  auto type_system_or_err =
+      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+                   std::move(err), "Unable to get DeclContext containing UID");
+    return CompilerDeclContext();
+  }
+
+  ClangASTContext *clang_ast_ctx =
+      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
   if (!clang_ast_ctx)
     return CompilerDeclContext();
 
   PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
   if (!pdb)
     return CompilerDeclContext();
 
   auto symbol = m_session_up->getSymbolById(uid);
   if (!symbol)
     return CompilerDeclContext();
 
   auto decl_context = pdb->GetDeclContextContainingSymbol(*symbol);
   assert(decl_context);
 
   return CompilerDeclContext(clang_ast_ctx, decl_context);
 }
 
 void SymbolFilePDB::ParseDeclsForContext(
     lldb_private::CompilerDeclContext decl_ctx) {
-  ClangASTContext *clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(
-      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus));
+  auto type_system_or_err =
+      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+                   std::move(err), "Unable to parse decls for context");
+    return;
+  }
+
+  ClangASTContext *clang_ast_ctx =
+      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
   if (!clang_ast_ctx)
     return;
 
   PDBASTParser *pdb = clang_ast_ctx->GetPDBParser();
   if (!pdb)
     return;
 
   pdb->ParseDeclsForDeclContext(
uint32_t SymbolFilePDB::FindTypes(
 
   // There is an assumption 'name' is not a regex
   FindTypesByName(name.GetStringRef(), parent_decl_ctx, max_matches, types);
 
   return types.GetSize();
 }
 
 void SymbolFilePDB::DumpClangAST(Stream &s) {
-  auto type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
-  auto clang = llvm::dyn_cast_or_null<ClangASTContext>(type_system);
-  if (!clang)
+  auto type_system_or_err =
+      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+                   std::move(err), "Unable to dump ClangAST");
     return;
-  clang->Dump(s);
+  }
+
+  auto *clang_type_system =
+      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
+  if (!clang_type_system)
+    return;
+  clang_type_system->Dump(s);
 }
 
 void SymbolFilePDB::FindTypesByRegex(
     const lldb_private::RegularExpression &regex, uint32_t max_matches,
     lldb_private::TypeMap &types) {
   // When searching by regex, we need to go out of our way to limit the search
   // space as much as possible since this searches EVERYTHING in the PDB,
   // manually doing regex comparisons.  PDB library isn't optimized for regex
size_t SymbolFilePDB::GetTypes(lldb_private::SymbolContextScope *sc_scope,
 
   for (auto type : type_collection) {
     type->GetForwardCompilerType();
     type_list.Insert(type->shared_from_this());
   }
   return type_list.GetSize() - old_size;
 }
 
-lldb_private::TypeSystem *
+llvm::Expected<lldb_private::TypeSystem &>
 SymbolFilePDB::GetTypeSystemForLanguage(lldb::LanguageType language) {
-  auto type_system =
+  auto type_system_or_err =
       m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
-  if (type_system)
-    type_system->SetSymbolFile(this);
-  return type_system;
+  if (type_system_or_err) {
+    type_system_or_err->SetSymbolFile(this);
+  }
+  return type_system_or_err;
 }
 
 PDBASTParser *SymbolFilePDB::GetPDBAstParser() {
-  auto type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
-  auto clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(type_system);
+  auto type_system_or_err =
+      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+                   std::move(err), "Unable to get PDB AST parser");
+    return nullptr;
+  }
+
+  auto *clang_type_system =
+      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
   if (!clang_type_system)
     return nullptr;
 
   return clang_type_system->GetPDBParser();
 }
 
 
 lldb_private::CompilerDeclContext SymbolFilePDB::FindNamespace(
     lldb_private::ConstString name,
     const lldb_private::CompilerDeclContext *parent_decl_ctx) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
-  auto type_system = GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
-  auto clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(type_system);
+  auto type_system_or_err =
+      GetTypeSystemForLanguage(lldb::eLanguageTypeC_plus_plus);
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+                   std::move(err), "Unable to find namespace {}",
+                   name.AsCString());
+    return CompilerDeclContext();
+  }
+
+  auto *clang_type_system =
+      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
   if (!clang_type_system)
     return CompilerDeclContext();
 
   PDBASTParser *pdb = clang_type_system->GetPDBParser();
   if (!pdb)
     return CompilerDeclContext();
 
   clang::DeclContext *decl_context = nullptr;
   if (parent_decl_ctx)
     decl_context = static_cast<clang::DeclContext *>(
         parent_decl_ctx->GetOpaqueDeclContext());
 
   auto namespace_decl =
       pdb->FindNamespaceDecl(decl_context, name.GetStringRef());
   if (!namespace_decl)
     return CompilerDeclContext();
 
-  return CompilerDeclContext(type_system,
+  return CompilerDeclContext(clang_type_system,
                              static_cast<clang::DeclContext *>(namespace_decl));
 }
 
 lldb_private::ConstString SymbolFilePDB::GetPluginName() {
   static ConstString g_name("pdb");
   return g_name;
 }
 

 bool SymbolFilePDB::DeclContextMatchesThisSymbolFile(
     const lldb_private::CompilerDeclContext *decl_ctx) {
   if (decl_ctx == nullptr || !decl_ctx->IsValid())
     return true;
 
   TypeSystem *decl_ctx_type_system = decl_ctx->GetTypeSystem();
   if (!decl_ctx_type_system)
     return false;
-  TypeSystem *type_system = GetTypeSystemForLanguage(
+  auto type_system_or_err = GetTypeSystemForLanguage(
       decl_ctx_type_system->GetMinimumLanguage(nullptr));
-  if (decl_ctx_type_system == type_system)
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(
+        lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+        std::move(err),
+        "Unable to determine if DeclContext matches this symbol file");
+    return false;
+  }
+
+  if (decl_ctx_type_system == &type_system_or_err.get())
     return true; // The type systems match, return true
 
   return false;
 }
 
 uint32_t SymbolFilePDB::GetCompilandId(const llvm::pdb::PDBSymbolData &data) {
   static const auto pred_upper = [](uint32_t lhs, SecContribInfo rhs) {
     return lhs < rhs.Offset;

lldb/trunk/source/Plugins/SystemRuntime/MacOSX/AppleGetItemInfoHandler.cpp

if (!m_get_item_info_impl_code) {
           return args_addr;
         }
       } else {
         LLDB_LOGF(log, "No get-item-info introspection code found.");
         return LLDB_INVALID_ADDRESS;
       }
 
       // Next make the runner function for our implementation utility function.
-      Status error;
-
-      TypeSystem *type_system =
+      auto type_system_or_err =
           thread.GetProcess()->GetTarget().GetScratchTypeSystemForLanguage(
-              nullptr, eLanguageTypeC);
+              eLanguageTypeC);
+      if (auto err = type_system_or_err.takeError()) {
+        LLDB_LOG_ERROR(log, std::move(err),
+                       "Error inseting get-item-info function");
+        return args_addr;
+      }
       CompilerType get_item_info_return_type =
-          type_system->GetBasicTypeFromAST(eBasicTypeVoid).GetPointerType();
+          type_system_or_err->GetBasicTypeFromAST(eBasicTypeVoid)
+              .GetPointerType();
 
+      Status error;
       get_item_info_caller = m_get_item_info_impl_code->MakeFunctionCaller(
           get_item_info_return_type, get_item_info_arglist,
           thread.shared_from_this(), error);
       if (error.Fail() || get_item_info_caller == nullptr) {
         LLDB_LOGF(log, "Error Inserting get-item-info function: \"%s\".",
                   error.AsCString());
         return args_addr;
       }

lldb/trunk/source/Symbol/SymbolFile.cpp

if (best_symfile_up) {
       // Let the winning symbol file parser initialize itself more completely
       // now that it has been chosen
       best_symfile_up->InitializeObject();
     }
   }
   return best_symfile_up.release();
 }
 
-TypeSystem *SymbolFile::GetTypeSystemForLanguage(lldb::LanguageType language) {
-  TypeSystem *type_system =
+llvm::Expected<TypeSystem &>
+SymbolFile::GetTypeSystemForLanguage(lldb::LanguageType language) {
+  auto type_system_or_err =
       m_obj_file->GetModule()->GetTypeSystemForLanguage(language);
-  if (type_system)
-    type_system->SetSymbolFile(this);
-  return type_system;
+  if (type_system_or_err) {
+    type_system_or_err->SetSymbolFile(this);
+  }
+  return type_system_or_err;
 }
 
 uint32_t SymbolFile::ResolveSymbolContext(const FileSpec &file_spec,
                                           uint32_t line, bool check_inlines,
                                           lldb::SymbolContextItem resolve_scope,
                                           SymbolContextList &sc_list) {
   return 0;
 }

lldb/trunk/source/Symbol/Type.cpp

 //===-- Type.cpp ------------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdio.h>
 
 #include "lldb/Core/Module.h"
 #include "lldb/Utility/DataBufferHeap.h"
 #include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Log.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
if (encoding_type) {
             encoding_type->GetForwardCompilerType().GetRValueReferenceType();
         break;
 
       default:
         llvm_unreachable("Unhandled encoding_data_type.");
       }
     } else {
       // We have no encoding type, return void?
-      TypeSystem *type_system =
+      auto type_system_or_err =
           m_symbol_file->GetTypeSystemForLanguage(eLanguageTypeC);
+      if (auto err = type_system_or_err.takeError()) {
+        LLDB_LOG_ERROR(
+            lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_SYMBOLS),
+            std::move(err),
+            "Unable to construct void type from ClangASTContext");
+      } else {
         CompilerType void_compiler_type =
-          type_system->GetBasicTypeFromAST(eBasicTypeVoid);
+            type_system_or_err->GetBasicTypeFromAST(eBasicTypeVoid);
         switch (m_encoding_uid_type) {
         case eEncodingIsUID:
           m_compiler_type = void_compiler_type;
           break;
 
         case eEncodingIsConstUID:
           m_compiler_type = void_compiler_type.AddConstModifier();
           break;
 
         case eEncodingIsRestrictUID:
           m_compiler_type = void_compiler_type.AddRestrictModifier();
           break;
 
         case eEncodingIsVolatileUID:
           m_compiler_type = void_compiler_type.AddVolatileModifier();
           break;
 
         case eEncodingIsTypedefUID:
           m_compiler_type = void_compiler_type.CreateTypedef(
               m_name.AsCString("__lldb_invalid_typedef_name"),
               GetSymbolFile()->GetDeclContextContainingUID(GetID()));
           break;
 
         case eEncodingIsPointerUID:
           m_compiler_type = void_compiler_type.GetPointerType();
           break;
 
         case eEncodingIsLValueReferenceUID:
           m_compiler_type = void_compiler_type.GetLValueReferenceType();
           break;
 
         case eEncodingIsRValueReferenceUID:
           m_compiler_type = void_compiler_type.GetRValueReferenceType();
           break;
 
         default:
           llvm_unreachable("Unhandled encoding_data_type.");
         }
       }
+    }
 
     // When we have a EncodingUID, our "m_flags.compiler_type_resolve_state" is
     // set to eResolveStateUnresolved so we need to update it to say that we
     // now have a forward declaration since that is what we created above.
     if (m_compiler_type.IsValid())
       m_flags.compiler_type_resolve_state = eResolveStateForward;
   }
 

lldb/trunk/source/Symbol/TypeSystem.cpp

 //
 
 #include "lldb/Symbol/TypeSystem.h"
 
 #include <set>
 
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Symbol/CompilerType.h"
+#include "lldb/Target/Language.h"
 
 using namespace lldb_private;
 using namespace lldb;
 
 TypeSystem::TypeSystem(LLVMCastKind kind) : m_kind(kind), m_sym_file(nullptr) {}
 
 TypeSystem::~TypeSystem() {}
 
for (auto pair : m_map) {
     if (type_system && !visited.count(type_system)) {
       visited.insert(type_system);
       if (!callback(type_system))
         break;
     }
   }
 }
 
-TypeSystem *TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language,
-                                                    Module *module,
-                                                    bool can_create) {
+llvm::Expected<TypeSystem &>
+TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language,
+                                        Module *module, bool can_create) {
+  llvm::Error error = llvm::Error::success();
+  assert(!error); // Check the success value when assertions are enabled
   std::lock_guard<std::mutex> guard(m_mutex);
+  if (m_clear_in_progress) {
+    error = llvm::make_error<llvm::StringError>(
+        "Unable to get TypeSystem because TypeSystemMap is being cleared",
+        llvm::inconvertibleErrorCode());
+  } else {
     collection::iterator pos = m_map.find(language);
-  if (pos != m_map.end())
-    return pos->second.get();
+    if (pos != m_map.end()) {
+      auto *type_system = pos->second.get();
+      if (type_system) {
+        llvm::consumeError(std::move(error));
+        return *type_system;
+      }
+      error = llvm::make_error<llvm::StringError>(
+          "TypeSystem for language " +
+              llvm::toStringRef(Language::GetNameForLanguageType(language)) +
+              " doesn't exist",
+          llvm::inconvertibleErrorCode());
+      return std::move(error);
+    }
 
     for (const auto &pair : m_map) {
       if (pair.second && pair.second->SupportsLanguage(language)) {
         // Add a new mapping for "language" to point to an already existing
         // TypeSystem that supports this language
-      AddToMap(language, pair.second);
-      return pair.second.get();
+        m_map[language] = pair.second;
+        if (pair.second.get()) {
+          llvm::consumeError(std::move(error));
+          return *pair.second.get();
+        }
+        error = llvm::make_error<llvm::StringError>(
+            "TypeSystem for language " +
+                llvm::toStringRef(Language::GetNameForLanguageType(language)) +
+                " doesn't exist",
+            llvm::inconvertibleErrorCode());
+        return std::move(error);
       }
     }
 
-  if (!can_create)
-    return nullptr;
+    if (!can_create) {
+      error = llvm::make_error<llvm::StringError>(
+          "Unable to find type system for language " +
+              llvm::toStringRef(Language::GetNameForLanguageType(language)),
+          llvm::inconvertibleErrorCode());
+    } else {
+      // Cache even if we get a shared pointer that contains a null type system
+      // back
+      auto type_system_sp = TypeSystem::CreateInstance(language, module);
+      m_map[language] = type_system_sp;
+      if (type_system_sp.get()) {
+        llvm::consumeError(std::move(error));
+        return *type_system_sp.get();
+      }
+      error = llvm::make_error<llvm::StringError>(
+          "TypeSystem for language " +
+              llvm::toStringRef(Language::GetNameForLanguageType(language)) +
+              " doesn't exist",
+          llvm::inconvertibleErrorCode());
+    }
+  }
 
-  // Cache even if we get a shared pointer that contains null type system back
-  lldb::TypeSystemSP type_system_sp =
-      TypeSystem::CreateInstance(language, module);
-  AddToMap(language, type_system_sp);
-  return type_system_sp.get();
+  return std::move(error);
 }
 
-TypeSystem *TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language,
-                                                    Target *target,
-                                                    bool can_create) {
+llvm::Expected<TypeSystem &>
+TypeSystemMap::GetTypeSystemForLanguage(lldb::LanguageType language,
+                                        Target *target, bool can_create) {
+  llvm::Error error = llvm::Error::success();
+  assert(!error); // Check the success value when assertions are enabled
   std::lock_guard<std::mutex> guard(m_mutex);
+  if (m_clear_in_progress) {
+    error = llvm::make_error<llvm::StringError>(
+        "Unable to get TypeSystem because TypeSystemMap is being cleared",
+        llvm::inconvertibleErrorCode());
+  } else {
     collection::iterator pos = m_map.find(language);
-  if (pos != m_map.end())
-    return pos->second.get();
+    if (pos != m_map.end()) {
+      auto *type_system = pos->second.get();
+      if (type_system) {
+        llvm::consumeError(std::move(error));
+        return *type_system;
+      }
+      error = llvm::make_error<llvm::StringError>(
+          "TypeSystem for language " +
+              llvm::toStringRef(Language::GetNameForLanguageType(language)) +
+              " doesn't exist",
+          llvm::inconvertibleErrorCode());
+      return std::move(error);
+    }
 
     for (const auto &pair : m_map) {
       if (pair.second && pair.second->SupportsLanguage(language)) {
         // Add a new mapping for "language" to point to an already existing
         // TypeSystem that supports this language
-
-      AddToMap(language, pair.second);
-      return pair.second.get();
+        m_map[language] = pair.second;
+        if (pair.second.get()) {
+          llvm::consumeError(std::move(error));
+          return *pair.second.get();
+        }
+        error = llvm::make_error<llvm::StringError>(
+            "TypeSystem for language " +
+                llvm::toStringRef(Language::GetNameForLanguageType(language)) +
+                " doesn't exist",
+            llvm::inconvertibleErrorCode());
+        return std::move(error);
       }
     }
 
-  if (!can_create)
-    return nullptr;
-
-  // Cache even if we get a shared pointer that contains null type system back
-  lldb::TypeSystemSP type_system_sp;
-  if (!m_clear_in_progress)
-    type_system_sp = TypeSystem::CreateInstance(language, target);
-
-  AddToMap(language, type_system_sp);
-  return type_system_sp.get();
+    if (!can_create) {
+      error = llvm::make_error<llvm::StringError>(
+          "Unable to find type system for language " +
+              llvm::toStringRef(Language::GetNameForLanguageType(language)),
+          llvm::inconvertibleErrorCode());
+    } else {
+      // Cache even if we get a shared pointer that contains a null type system
+      // back
+      auto type_system_sp = TypeSystem::CreateInstance(language, target);
+      m_map[language] = type_system_sp;
+      if (type_system_sp.get()) {
+        llvm::consumeError(std::move(error));
+        return *type_system_sp.get();
+      }
+      error = llvm::make_error<llvm::StringError>(
+          "TypeSystem for language " +
+              llvm::toStringRef(Language::GetNameForLanguageType(language)) +
+              " doesn't exist",
+          llvm::inconvertibleErrorCode());
+    }
   }
 
-void TypeSystemMap::AddToMap(lldb::LanguageType language,
-                             lldb::TypeSystemSP const &type_system_sp) {
-  if (!m_clear_in_progress)
-    m_map[language] = type_system_sp;
+  return std::move(error);
 }

lldb/trunk/source/Target/StackFrame.cpp

 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrameRecognizer.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
+#include "lldb/Utility/Log.h"
 #include "lldb/Utility/RegisterValue.h"
 
 #include "lldb/lldb-enumerations.h"
 
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
for (const Instruction::Operand &operand : operands) {
     }
 
     switch (base_and_offset.first->m_type) {
     case Instruction::Operand::Type::Immediate: {
       lldb_private::Address addr;
       if (target_sp->ResolveLoadAddress(base_and_offset.first->m_immediate +
                                             base_and_offset.second,
                                         addr)) {
-        TypeSystem *c_type_system =
-            target_sp->GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC);
-        if (!c_type_system) {
+        auto c_type_system_or_err =
+            target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC);
+        if (auto err = c_type_system_or_err.takeError()) {
+          LLDB_LOG_ERROR(
+              lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD),
+              std::move(err), "Unable to guess value for given address");
           return ValueObjectSP();
         } else {
           CompilerType void_ptr_type =
-              c_type_system
+              c_type_system_or_err
                   ->GetBasicTypeFromAST(lldb::BasicType::eBasicTypeChar)
                   .GetPointerType();
           return ValueObjectMemory::Create(this, "", addr, void_ptr_type);
         }
       } else {
         return ValueObjectSP();
       }
       break;

lldb/trunk/source/Target/Target.cpp

 void Target::ImageSearchPathsChanged(const PathMappingList &path_list,
                                      void *baton) {
   Target *target = (Target *)baton;
   ModuleSP exe_module_sp(target->GetExecutableModule());
   if (exe_module_sp)
     target->SetExecutableModule(exe_module_sp, eLoadDependentsYes);
 }
 
-TypeSystem *Target::GetScratchTypeSystemForLanguage(Status *error,
-                                                    lldb::LanguageType language,
-                                                    bool create_on_demand) {
+llvm::Expected<TypeSystem &>
+Target::GetScratchTypeSystemForLanguage(lldb::LanguageType language,
   if (!m_valid)
-    return nullptr;
-
-  if (error) {
-    error->Clear();
-  }
+    return llvm::make_error<llvm::StringError>("Invalid Target",
+                                               llvm::inconvertibleErrorCode());
 
   if (language == eLanguageTypeMipsAssembler // GNU AS and LLVM use it for all
                                              // assembly code
       || language == eLanguageTypeUnknown) {
     std::set<lldb::LanguageType> languages_for_types;
     std::set<lldb::LanguageType> languages_for_expressions;
 
     Language::GetLanguagesSupportingTypeSystems(languages_for_types,
                                                 languages_for_expressions);
 
     if (languages_for_expressions.count(eLanguageTypeC)) {
       language = eLanguageTypeC; // LLDB's default.  Override by setting the
                                  // target language.
     } else {
       if (languages_for_expressions.empty()) {
-        return nullptr;
+        return llvm::make_error<llvm::StringError>(
+            "No expression support for any languages",
+            llvm::inconvertibleErrorCode());
       } else {
         language = *languages_for_expressions.begin();
       }
     }
   }
 
   return m_scratch_type_system_map.GetTypeSystemForLanguage(language, this,
                                                             create_on_demand);
 }
 
 PersistentExpressionState *
 Target::GetPersistentExpressionStateForLanguage(lldb::LanguageType language) {
-  TypeSystem *type_system =
-      GetScratchTypeSystemForLanguage(nullptr, language, true);
+  auto type_system_or_err = GetScratchTypeSystemForLanguage(language, true);
 
-  if (type_system) {
-    return type_system->GetPersistentExpressionState();
-  } else {
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET),
+                   std::move(err),
+                   "Unable to get persistent expression state for language {}",
+                   Language::GetNameForLanguageType(language));
     return nullptr;
   }
+
+  return type_system_or_err->GetPersistentExpressionState();
 }
 
 UserExpression *Target::GetUserExpressionForLanguage(
     llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language,
     Expression::ResultType desired_type,
     const EvaluateExpressionOptions &options, ValueObject *ctx_obj,
     Status &error) {
-  Status type_system_error;
-
-  TypeSystem *type_system =
-      GetScratchTypeSystemForLanguage(&type_system_error, language);
-  UserExpression *user_expr = nullptr;
-
-  if (!type_system) {
+  auto type_system_or_err = GetScratchTypeSystemForLanguage(language);
+  if (auto err = type_system_or_err.takeError()) {
     error.SetErrorStringWithFormat(
         "Could not find type system for language %s: %s",
         Language::GetNameForLanguageType(language),
-        type_system_error.AsCString());
+        llvm::toString(std::move(err)).c_str());
     return nullptr;
   }
 
-  user_expr = type_system->GetUserExpression(expr, prefix, language,
-                                             desired_type, options, ctx_obj);
+  auto *user_expr = type_system_or_err->GetUserExpression(
+      expr, prefix, language, desired_type, options, ctx_obj);
   if (!user_expr)
     error.SetErrorStringWithFormat(
         "Could not create an expression for language %s",
         Language::GetNameForLanguageType(language));
 
   return user_expr;
 }
 
 FunctionCaller *Target::GetFunctionCallerForLanguage(
     lldb::LanguageType language, const CompilerType &return_type,
     const Address &function_address, const ValueList &arg_value_list,
     const char *name, Status &error) {
-  Status type_system_error;
-  TypeSystem *type_system =
-      GetScratchTypeSystemForLanguage(&type_system_error, language);
-  FunctionCaller *persistent_fn = nullptr;
-
-  if (!type_system) {
+  auto type_system_or_err = GetScratchTypeSystemForLanguage(language);
+  if (auto err = type_system_or_err.takeError()) {
     error.SetErrorStringWithFormat(
         "Could not find type system for language %s: %s",
         Language::GetNameForLanguageType(language),
-        type_system_error.AsCString());
-    return persistent_fn;
+        llvm::toString(std::move(err)).c_str());
+    return nullptr;
   }
 
-  persistent_fn = type_system->GetFunctionCaller(return_type, function_address,
-                                                 arg_value_list, name);
+  auto *persistent_fn = type_system_or_err->GetFunctionCaller(
+      return_type, function_address, arg_value_list, name);
   if (!persistent_fn)
     error.SetErrorStringWithFormat(
         "Could not create an expression for language %s",
         Language::GetNameForLanguageType(language));
 
   return persistent_fn;
 }
 
 UtilityFunction *
 Target::GetUtilityFunctionForLanguage(const char *text,
                                       lldb::LanguageType language,
                                       const char *name, Status &error) {
-  Status type_system_error;
-  TypeSystem *type_system =
-      GetScratchTypeSystemForLanguage(&type_system_error, language);
-  UtilityFunction *utility_fn = nullptr;
+  auto type_system_or_err = GetScratchTypeSystemForLanguage(language);
 
-  if (!type_system) {
+  if (auto err = type_system_or_err.takeError()) {
     error.SetErrorStringWithFormat(
         "Could not find type system for language %s: %s",
         Language::GetNameForLanguageType(language),
-        type_system_error.AsCString());
-    return utility_fn;
+        llvm::toString(std::move(err)).c_str());
+    return nullptr;
   }
 
-  utility_fn = type_system->GetUtilityFunction(text, name);
+  auto *utility_fn = type_system_or_err->GetUtilityFunction(text, name);
   if (!utility_fn)
     error.SetErrorStringWithFormat(
         "Could not create an expression for language %s",
         Language::GetNameForLanguageType(language));
 
   return utility_fn;
 }
 
 ClangASTContext *Target::GetScratchClangASTContext(bool create_on_demand) {
-  if (m_valid) {
-    if (TypeSystem *type_system = GetScratchTypeSystemForLanguage(
-            nullptr, eLanguageTypeC, create_on_demand))
-      return llvm::dyn_cast<ClangASTContext>(type_system);
-  }
+  if (!m_valid)
+    return nullptr;
+
+  auto type_system_or_err =
+          GetScratchTypeSystemForLanguage(eLanguageTypeC, create_on_demand);
+  if (auto err = type_system_or_err.takeError()) {
+    LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET),
+                   std::move(err), "Couldn't get scratch ClangASTContext");
     return nullptr;
   }
+  return llvm::dyn_cast<ClangASTContext>(&type_system_or_err.get());
+}
 
 ClangASTImporterSP Target::GetClangASTImporter() {
   if (m_valid) {
     if (!m_ast_importer_sp) {
       m_ast_importer_sp = std::make_shared<ClangASTImporter>();
     }
     return m_ast_importer_sp;
   }
ExpressionResults Target::EvaluateExpression(
   } else if (m_process_sp) {
     m_process_sp->CalculateExecutionContext(exe_ctx);
   } else {
     CalculateExecutionContext(exe_ctx);
   }
 
   // Make sure we aren't just trying to see the value of a persistent variable
   // (something like "$0")
-  lldb::ExpressionVariableSP persistent_var_sp;
   // Only check for persistent variables the expression starts with a '$'
-  if (expr[0] == '$')
-    persistent_var_sp = GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC)
-                            ->GetPersistentExpressionState()
-                            ->GetVariable(expr);
-
+  lldb::ExpressionVariableSP persistent_var_sp;
+  if (expr[0] == '$') {
+    auto type_system_or_err =
+            GetScratchTypeSystemForLanguage(eLanguageTypeC);
+    if (auto err = type_system_or_err.takeError()) {
+      LLDB_LOG_ERROR(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET),
+                     std::move(err), "Unable to get scratch type system");
+    } else {
+      persistent_var_sp =
+          type_system_or_err->GetPersistentExpressionState()->GetVariable(expr);
+    }
+  }
   if (persistent_var_sp) {
     result_valobj_sp = persistent_var_sp->GetValueObject();
     execution_results = eExpressionCompleted;
   } else {
     llvm::StringRef prefix = GetExpressionPrefixContents();
     Status error;
     execution_results =
         UserExpression::Evaluate(exe_ctx, options, expr, prefix,

lldb/trunk/source/Target/ThreadPlanTracer.cpp

Disassembler *ThreadPlanAssemblyTracer::GetDisassembler() {
   if (!m_disassembler_sp)
     m_disassembler_sp = Disassembler::FindPlugin(
         m_thread.GetProcess()->GetTarget().GetArchitecture(), nullptr, nullptr);
   return m_disassembler_sp.get();
 }
 
 TypeFromUser ThreadPlanAssemblyTracer::GetIntPointerType() {
   if (!m_intptr_type.IsValid()) {
-    TargetSP target_sp(m_thread.CalculateTarget());
-    if (target_sp) {
-      TypeSystem *type_system =
-          target_sp->GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC);
-      if (type_system)
-        m_intptr_type =
-            TypeFromUser(type_system->GetBuiltinTypeForEncodingAndBitSize(
+    if (auto target_sp = m_thread.CalculateTarget()) {
+      auto type_system_or_err =
+          target_sp->GetScratchTypeSystemForLanguage(eLanguageTypeC);
+      if (auto err = type_system_or_err.takeError()) {
+        LLDB_LOG_ERROR(
+            lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_TYPES),
+            std::move(err),
+            "Unable to get integer pointer type from TypeSystem");
+      } else {
+        m_intptr_type = TypeFromUser(
+            type_system_or_err->GetBuiltinTypeForEncodingAndBitSize(
                 eEncodingUint,
                 target_sp->GetArchitecture().GetAddressByteSize() * 8));
       }
     }
+  }
   return m_intptr_type;
 }
 
 ThreadPlanAssemblyTracer::~ThreadPlanAssemblyTracer() = default;
 
 void ThreadPlanAssemblyTracer::TracingStarted() {
   RegisterContext *reg_ctx = m_thread.GetRegisterContext().get();
 

lldb/trunk/tools/lldb-test/lldb-test.cpp

 Error opts::symbols::dumpAST(lldb_private::Module &Module) {
   SymbolVendor &plugin = *Module.GetSymbolVendor();
    Module.ParseAllDebugSymbols();
 
   auto symfile = plugin.GetSymbolFile();
   if (!symfile)
     return make_string_error("Module has no symbol file.");
 
-  auto clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(
-      symfile->GetTypeSystemForLanguage(eLanguageTypeC_plus_plus));
+  auto type_system_or_err =
+      symfile->GetTypeSystemForLanguage(eLanguageTypeC_plus_plus);
+  if (!type_system_or_err)
+    return make_string_error("Can't retrieve ClangASTContext");
+
+  auto *clang_ast_ctx =
+      llvm::dyn_cast_or_null<ClangASTContext>(&type_system_or_err.get());
   if (!clang_ast_ctx)
-    return make_string_error("Can't retrieve Clang AST context.");
+    return make_string_error("Retrieved TypeSystem was not a ClangASTContext");
 
   auto ast_ctx = clang_ast_ctx->getASTContext();
   if (!ast_ctx)
     return make_string_error("Can't retrieve AST context.");
 
   auto tu = ast_ctx->getTranslationUnitDecl();
   if (!tu)
     return make_string_error("Can't retrieve translation unit declaration.");