[stable/20250402] Cherry-pick "[lldb] Upgrade CompilerType::GetBitSize to return llvm::Expected (llvm#129601)"

This patch pushes the error handling boundary for the GetBitSize()
methods from Runtime into the Type and CompilerType APIs. This makes
it easier to diagnose problems thanks to more meaningful error
messages being available. GetBitSize() is often the first thing LLDB
asks about a type, so this method is particularly important for a
better user experience.

rdar://145667239
(cherry picked from commit 878a64f)

(cherry picked from commit 642dcd7)
(cherry picked from commit d3e7a33)

Author: adrian-prantl

lldb/source/Plugins/ExpressionParser/Swift/SwiftExpressionParser.cpp

@@ -1050,9 +1050,12 @@ MaterializeVariable(SwiftASTManipulatorBase::VariableInfo &variable,
     // this check scattered in several places in the codebase, we should at
     // some point centralize it.
     lldb::StackFrameSP stack_frame_sp = stack_frame_wp.lock();
-    std::optional<uint64_t> size =
+    auto size_or_err =
         variable.GetType().GetByteSize(stack_frame_sp.get());
-    if (repl && size && *size == 0) {
+    if (!size_or_err)
+      return size_or_err.takeError();
+    uint64_t size = *size_or_err;
+    if (repl && size == 0) {
       auto &repl_mat = *llvm::cast<SwiftREPLMaterializer>(&materializer);
       offset = repl_mat.AddREPLResultVariable(
           variable.GetType(), variable.GetDecl(),

lldb/source/Plugins/ExpressionParser/Swift/SwiftREPLMaterializer.cpp

@@ -158,7 +158,13 @@ class EntityREPLResultVariable : public Materializer::Entity {
     ret->ValueUpdated();
 
     if (variable) {
-      const size_t pvar_byte_size = ret->GetByteSize().value_or(0);
+      auto pvar_byte_size_or_err = ret->GetByteSize();
+      if (!pvar_byte_size_or_err) {
+        err = Status::FromError(pvar_byte_size_or_err.takeError());
+        return;
+      }
+
+      const uint64_t pvar_byte_size = *pvar_byte_size_or_err;
       uint8_t *pvar_data = ret->GetValueBytes();
 
       Status read_error;
@@ -226,9 +232,13 @@ class EntityREPLResultVariable : public Materializer::Entity {
       demangle_ctx.clear();
     }
 
-    std::optional<uint64_t> size =
+    auto size_or_err =
         m_type.GetByteSize(execution_unit->GetBestExecutionContextScope());
-    if (size && *size == 0) {
+    if (!size_or_err) {
+      err = Status::FromError(size_or_err.takeError());
+      return;
+    }
+    if (*size_or_err == 0) {
       MakeREPLResult(*execution_unit, err, nullptr);
       return;
     }
@@ -413,10 +423,15 @@ class EntityREPLPersistentVariable : public Materializer::Entity {
               FixupResilientGlobal(var_addr, compiler_type, *execution_unit,
                                    exe_scope->CalculateProcess(), read_error);
 
+        auto size_or_err = m_persistent_variable_sp->GetByteSize();
+        if (!size_or_err) {
+          err = Status::FromError(size_or_err.takeError());
+          return;
+        }
+
         // FIXME: This may not work if the value is not bitwise-takable.
-        execution_unit->ReadMemory(
-            m_persistent_variable_sp->GetValueBytes(), var_addr,
-            m_persistent_variable_sp->GetByteSize().value_or(0), read_error);
+        execution_unit->ReadMemory(m_persistent_variable_sp->GetValueBytes(),
+                                   var_addr, *size_or_err, read_error);
 
         if (!read_error.Success()) {
           err = Status::FromErrorStringWithFormatv(
@@ -477,12 +492,13 @@ class EntityREPLPersistentVariable : public Materializer::Entity {
       if (!err.Success()) {
         dump_stream.Printf("  <could not be read>\n");
       } else {
-        DataBufferHeap data(m_persistent_variable_sp->GetByteSize().value_or(0),
-                            0);
+        uint64_t size =
+            llvm::expectedToOptional(m_persistent_variable_sp->GetByteSize())
+                .value_or(0);
+
+        DataBufferHeap data(size, 0);
 
-        map.ReadMemory(data.GetBytes(), target_address,
-                       m_persistent_variable_sp->GetByteSize().value_or(0),
-                       err);
+        map.ReadMemory(data.GetBytes(), target_address, size, err);
 
         if (!err.Success()) {
           dump_stream.Printf("  <could not be read>\n");

lldb/source/Plugins/Language/Swift/SwiftFormatters.cpp

@@ -2050,8 +2050,8 @@ bool lldb_private::formatters::swift::SIMDVector_SummaryProvider(
     return false;
 
   ExecutionContext exe_ctx = valobj.GetExecutionContextRef().Lock(true);
-  std::optional<uint64_t> opt_type_size =
-    simd_type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
+  std::optional<uint64_t> opt_type_size = llvm::expectedToOptional(
+      simd_type.GetByteSize(exe_ctx.GetBestExecutionContextScope()));
   if (!opt_type_size)
     return false;
   uint64_t type_size = *opt_type_size;
@@ -2065,8 +2065,8 @@ bool lldb_private::formatters::swift::SIMDVector_SummaryProvider(
   if (!arg_type)
     return false;
 
-  std::optional<uint64_t> opt_arg_size =
-      arg_type.GetByteSize(exe_ctx.GetBestExecutionContextScope());
+  std::optional<uint64_t> opt_arg_size = llvm::expectedToOptional(
+      arg_type.GetByteSize(exe_ctx.GetBestExecutionContextScope()));
   if (!opt_arg_size)
     return false;
   uint64_t arg_size = *opt_arg_size;