[Plugins/Process] Remove direct use of ClangASTContext from InferiorCallPOSIX

[xiaobai]

Summary

InferiorCallPOSIX directly grabs a ClangASTContext from the Target it
has and does no error checking. I don't think these functions have a
reason to know about clang specifically. Additionally, using
GetScratchTypeSystemForLanguage forces us to do error checking since
it returns an Expected.

lldb/trunk/source/Plugins/Process/Utility/InferiorCallPOSIX.cpp

 //===-- InferiorCallPOSIX.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 "InferiorCallPOSIX.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Expression/DiagnosticManager.h"
 #include "lldb/Host/Config.h"
-#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadPlanCallFunction.h"
 
 #ifndef LLDB_DISABLE_POSIX
if (sc_list.GetContextAtIndex(0, sc)) {
           prot_arg |= PROT_READ;
         if (prot & eMmapProtWrite)
           prot_arg |= PROT_WRITE;
       }
 
       AddressRange mmap_range;
       if (sc.GetAddressRange(range_scope, 0, use_inline_block_range,
                              mmap_range)) {
-        ClangASTContext *clang_ast_context =
-            process->GetTarget().GetScratchClangASTContext();
-        CompilerType clang_void_ptr_type =
-            clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
+        auto type_system_or_err =
+            process->GetTarget().GetScratchTypeSystemForLanguage(
+                eLanguageTypeC);
+        if (!type_system_or_err) {
+          llvm::consumeError(type_system_or_err.takeError());
+          return false;
+        }
+        CompilerType void_ptr_type =
+            type_system_or_err->GetBasicTypeFromAST(eBasicTypeVoid)
+                .GetPointerType();
         const ArchSpec arch = process->GetTarget().GetArchitecture();
         MmapArgList args =
             process->GetTarget().GetPlatform()->GetMmapArgumentList(
                 arch, addr, length, prot_arg, flags, fd, offset);
         lldb::ThreadPlanSP call_plan_sp(
             new ThreadPlanCallFunction(*thread, mmap_range.GetBaseAddress(),
-                                       clang_void_ptr_type, args, options));
+                                       void_ptr_type, args, options));
         if (call_plan_sp) {
           DiagnosticManager diagnostics;
 
           StackFrame *frame = thread->GetStackFrameAtIndex(0).get();
           if (frame) {
             ExecutionContext exe_ctx;
             frame->CalculateExecutionContext(exe_ctx);
             ExpressionResults result = process->RunThreadPlan(
bool lldb_private::InferiorCall(Process *process, const Address *address,
   options.SetStopOthers(true);
   options.SetUnwindOnError(true);
   options.SetIgnoreBreakpoints(true);
   options.SetTryAllThreads(true);
   options.SetDebug(false);
   options.SetTimeout(process->GetUtilityExpressionTimeout());
   options.SetTrapExceptions(trap_exceptions);
 
-  ClangASTContext *clang_ast_context =
-      process->GetTarget().GetScratchClangASTContext();
-  CompilerType clang_void_ptr_type =
-      clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
+  auto type_system_or_err =
+      process->GetTarget().GetScratchTypeSystemForLanguage(eLanguageTypeC);
+  if (!type_system_or_err) {
+    llvm::consumeError(type_system_or_err.takeError());
+    return false;
+  }
+  CompilerType void_ptr_type =
+      type_system_or_err->GetBasicTypeFromAST(eBasicTypeVoid).GetPointerType();
   lldb::ThreadPlanSP call_plan_sp(
-      new ThreadPlanCallFunction(*thread, *address, clang_void_ptr_type,
+      new ThreadPlanCallFunction(*thread, *address, void_ptr_type,
                                  llvm::ArrayRef<addr_t>(), options));
   if (call_plan_sp) {
     DiagnosticManager diagnostics;
 
     StackFrame *frame = thread->GetStackFrameAtIndex(0).get();
     if (frame) {
       ExecutionContext exe_ctx;
       frame->CalculateExecutionContext(exe_ctx);