[lldb] Adapt Swift plugin to changes in CompilerType API

Author: adrian-prantl

lldb/source/Expression/Materializer.cpp

@@ -545,9 +545,12 @@ class EntityVariableBase : public Materializer::Entity {
         valobj_sp->GetData(data, extract_error);
         if (!extract_error.Success()) {
           if (valobj_type.GetMinimumLanguage() == lldb::eLanguageTypeSwift) {
-            std::optional<uint64_t> size =
-                valobj_type.GetByteSize(frame_sp.get());
-            if (size && *size == 0) {
+            auto size_or_err = valobj_type.GetByteSize(frame_sp.get());
+            if (!size_or_err) {
+              err = Status::FromError(size_or_err.takeError());
+              return;
+            }
+            if (*size_or_err == 0) {
               // We don't need to materialize empty structs in Swift.
               return;
             }
@@ -676,14 +679,19 @@ class EntityVariableBase : public Materializer::Entity {
 
       Status extract_error;
 
-      map.GetMemoryData(data, m_temporary_allocation,
-                        valobj_sp->GetByteSize().value_or(0), extract_error);
+      map.GetMemoryData(
+          data, m_temporary_allocation,
+          llvm::expectedToOptional(valobj_sp->GetByteSize()).value_or(0),
+          extract_error);
 
       if (!extract_error.Success()) {
         if (valobj_type.GetMinimumLanguage() == lldb::eLanguageTypeSwift) {
-          std::optional<uint64_t> size =
-              valobj_type.GetByteSize(frame_sp.get());
-          if (size && *size == 0)
+          auto size_or_err = valobj_type.GetByteSize(frame_sp.get());
+          if (!size_or_err) {
+            err = Status::FromError(size_or_err.takeError());
+            return;
+          }
+          if (*size_or_err == 0)
             // We don't need to dematerialize empty structs in Swift.
             return;
         }

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.cpp

@@ -1761,8 +1761,8 @@ void SwiftLanguageRuntime::WillStartExecutingUserExpression(
     return;
   }
   ConstString BoolName("bool");
-  std::optional<uint64_t> bool_size =
-      ts->GetBuiltinTypeByName(BoolName).GetByteSize(nullptr);
+  std::optional<uint64_t> bool_size = llvm::expectedToOptional(
+      ts->GetBuiltinTypeByName(BoolName).GetByteSize(nullptr));
   if (!bool_size)
     return;
 
@@ -1836,8 +1836,8 @@ void SwiftLanguageRuntime::DidFinishExecutingUserExpression(
     return;
   }
   ConstString BoolName("bool");
-  std::optional<uint64_t> bool_size =
-      ts->GetBuiltinTypeByName(BoolName).GetByteSize(nullptr);
+  std::optional<uint64_t> bool_size = llvm::expectedToOptional(
+      ts->GetBuiltinTypeByName(BoolName).GetByteSize(nullptr));
   if (!bool_size)
     return;
 

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.h

@@ -418,7 +418,7 @@ class SwiftLanguageRuntime : public LanguageRuntime {
                                         ExecutionContext *exe_ctx);
 
   /// Ask Remote Mirrors for the size of a Swift type.
-  std::optional<uint64_t> GetBitSize(CompilerType type,
+  llvm::Expected<uint64_t> GetBitSize(CompilerType type,
                                       ExecutionContextScope *exe_scope);
 
   /// Ask Remote mirrors for the stride of a Swift type.

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeDynamicTypeResolution.cpp

@@ -381,7 +381,8 @@ class LLDBTypeInfoProvider : public swift::remote::TypeInfoProvider {
       return nullptr;
     TypeSystemSwiftTypeRef &typesystem = *m_ts;
     // Build a TypeInfo for the Clang type.
-    auto size = clang_type.GetByteSize(exe_scope);
+    std::optional<uint64_t> size =
+        llvm::expectedToOptional(clang_type.GetByteSize(exe_scope));
     auto bit_align = clang_type.GetTypeBitAlign(exe_scope);
     std::vector<swift::reflection::FieldInfo> fields;
     if (clang_type.IsAggregateType()) {
@@ -1214,9 +1215,11 @@ llvm::Expected<CompilerType> SwiftLanguageRuntime::GetChildCompilerTypeAtIndex(
   if (auto pack_element_type = ts->GetSILPackElementAtIndex(type, idx)) {
     llvm::raw_string_ostream os(child_name);
     os << '.' << idx;
-    child_byte_size =
-        GetBitSize(pack_element_type, exe_ctx.GetBestExecutionContextScope())
-            .value_or(0);
+    auto size_or_err =
+        GetBitSize(pack_element_type, exe_ctx.GetBestExecutionContextScope());
+    if (!size_or_err)
+      return size_or_err.takeError();
+    child_byte_size = *size_or_err;
     int stack_dir = -1;
     child_byte_offset = ts->GetPointerByteSize() * idx * stack_dir;
     child_bitfield_bit_size = 0;
@@ -2236,7 +2239,9 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Existential(
 
 
   if (use_local_buffer)
-    PushLocalBuffer(existential_address, in_value.GetByteSize().value_or(0));
+    PushLocalBuffer(
+        existential_address,
+        llvm::expectedToOptional(in_value.GetByteSize()).value_or(0));
 
   swift::remote::RemoteAddress remote_existential(existential_address);
 
@@ -2522,7 +2527,7 @@ CompilerType SwiftLanguageRuntime::BindGenericTypeParameters(
       LLDB_LOG_ERROR(
           GetLog(LLDBLog::Expressions | LLDBLog::Types),
           type_ref_or_err.takeError(),
-          "Couldn't get rype ref when binding generic type parameters: {0}");
+          "Couldn't get type ref when binding generic type parameters: {0}");
       failure = true;
       return;
     }
@@ -2687,8 +2692,8 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Value(
   ExecutionContextScope *exe_scope = exe_ctx.GetBestExecutionContextScope();
   if (!exe_scope)
     return false;
-  std::optional<uint64_t> size =
-      bound_type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
+  std::optional<uint64_t> size = llvm::expectedToOptional(
+      bound_type.GetByteSize(exe_ctx.GetBestExecutionContextScope()));
   if (!size)
     return false;
   AddressType address_type;
@@ -2704,7 +2709,8 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress_Value(
     if (in_value_buffer.empty())
       return false;
     // If the dynamic type doesn't in the buffer we can't use it either.
-    if (in_value_buffer.size() < bound_type.GetByteSize(exe_scope))
+    if (in_value_buffer.size() <
+        llvm::expectedToOptional(bound_type.GetByteSize(exe_scope)).value_or(0))
       return false;
 
     value_type = Value::GetValueTypeFromAddressType(address_type);
@@ -2810,8 +2816,9 @@ Value::ValueType SwiftLanguageRuntime::GetValueType(
       }
 
       if (use_local_buffer)
-        PushLocalBuffer(existential_address,
-                        in_value.GetByteSize().value_or(0));
+        PushLocalBuffer(
+            existential_address,
+            llvm::expectedToOptional(in_value.GetByteSize()).value_or(0));
 
       // Read the value witness table and check if the data is inlined in
       // the existential container or not.
@@ -3331,7 +3338,10 @@ SwiftLanguageRuntime::GetTypeRef(CompilerType type,
   auto type_ref_or_err = reflection_ctx->GetTypeRef(
       dem, node, module_holder->GetDescriptorFinder());
   if (!type_ref_or_err)
-    return type_ref_or_err.takeError();
+    return llvm::joinErrors(
+        llvm::createStringError("cannot get typeref for type %s",
+                                type.GetMangledTypeName().GetCString()),
+        type_ref_or_err.takeError());
 
   if (log && log->GetVerbose()) {
     std::stringstream ss;
@@ -3537,14 +3547,12 @@ SwiftLanguageRuntime::ResolveTypeAlias(CompilerType alias) {
   return llvm::createStringError("cannot resolve type alias via reflection");
 }
 
-std::optional<uint64_t>
+llvm::Expected<uint64_t>
 SwiftLanguageRuntime::GetBitSize(CompilerType type,
                                  ExecutionContextScope *exe_scope) {
   auto type_info_or_err = GetSwiftRuntimeTypeInfo(type, exe_scope);
-  if (!type_info_or_err) {
-    LLDB_LOG_ERROR(GetLog(LLDBLog::Types), type_info_or_err.takeError(), "{0}");
-    return {};
-  }
+  if (!type_info_or_err)
+    return type_info_or_err.takeError();
 
   return type_info_or_err->getSize() * 8;
 }

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeRemoteAST.cpp

@@ -245,7 +245,9 @@ SwiftLanguageRuntime::GetDynamicTypeAndAddress_ExistentialRemoteAST(
   if (!swift_type)
     return {};
   if (use_local_buffer)
-    PushLocalBuffer(existential_address, in_value.GetByteSize().value_or(0));
+    PushLocalBuffer(
+        existential_address,
+        llvm::expectedToOptional(in_value.GetByteSize()).value_or(0));
 
   auto result = remote_ast.getDynamicTypeAndAddressForExistential(
       remote_existential, swift_type);