[lldb] Convert BindGenericTypeParameters to llvm::Expected

adrian-prantl · adrian-prantl · commit 8ce32abe53ff · 2025-05-14T08:09:47.000-07:00
(cherry picked from commit e48e8aa)
diff --git a/lldb/source/Plugins/ExpressionParser/Swift/SwiftExpressionParser.cpp b/lldb/source/Plugins/ExpressionParser/Swift/SwiftExpressionParser.cpp
@@ -470,7 +470,9 @@ static CompilerType GetSwiftTypeForVariableValueObject(
   if (!result)
     return {};
   if (SwiftASTManipulator::ShouldBindGenericTypes(bind_generic_types))
-    result = runtime->BindGenericTypeParameters(*stack_frame_sp, result);
+    result = llvm::expectedToOptional(
+                 runtime->BindGenericTypeParameters(*stack_frame_sp, result))
+                 .value_or(CompilerType());
   if (!result)
     return {};
   if (!result.GetTypeSystem()->SupportsLanguage(lldb::eLanguageTypeSwift))
@@ -606,12 +608,17 @@ AddRequiredAliases(Block *block, lldb::StackFrameSP &stack_frame_sp,
 
   auto *stack_frame = stack_frame_sp.get();
   if (SwiftASTManipulator::ShouldBindGenericTypes(bind_generic_types)) {
-    imported_self_type = swift_runtime->BindGenericTypeParameters(
+    auto bound_type_or_err = swift_runtime->BindGenericTypeParameters(
         *stack_frame, imported_self_type);
-    if (!imported_self_type)
-      return llvm::createStringError(
-          "Unable to add the aliases the expression needs because the Swift "
-          "expression parser couldn't bind the type parameters for self.");
+    if (!bound_type_or_err)
+      return llvm::joinErrors(
+          llvm::createStringError(
+              "Unable to add the aliases the expression needs because the "
+              "Swift expression parser couldn't bind the type parameters for "
+              "self."),
+          bound_type_or_err.takeError());
+
+    imported_self_type = *bound_type_or_err;
   }
 
   {
@@ -1224,16 +1231,17 @@ AddArchetypeTypeAliases(std::unique_ptr<SwiftASTManipulator> &code_manipulator,
     auto flavor = SwiftLanguageRuntime::GetManglingFlavor(type_name);
     auto dependent_type = typeref_typesystem->CreateGenericTypeParamType(
         info.depth, info.index, flavor);
-    auto bound_type =
+    auto bound_type_or_err =
         runtime->BindGenericTypeParameters(stack_frame, dependent_type);
-    if (!bound_type) {
-      LLDB_LOG(
-          log,
+    if (!bound_type_or_err) {
+      LLDB_LOG_ERROR(
+          log, bound_type_or_err.takeError(),
           "[AddArchetypeTypeAliases] Could not bind dependent generic param "
-          "type {0}",
+          "type {1}: {0}",
           dependent_type.GetMangledTypeName());
       continue;
     }
+    auto bound_type = *bound_type_or_err;
 
     LLDB_LOG(log,
              "[AddArchetypeTypeAliases] Binding dependent generic param "
diff --git a/lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.cpp b/lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.cpp
@@ -868,8 +868,14 @@ std::string SwiftLanguageRuntime::GetObjectDescriptionExpr_Copy(
 
   auto swift_ast_ctx =
       static_type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>();
-  if (swift_ast_ctx)
-    static_type = BindGenericTypeParameters(*frame_sp, static_type);
+  if (swift_ast_ctx) {
+    auto bound_type_or_err = BindGenericTypeParameters(*frame_sp, static_type);
+    if (!bound_type_or_err) {
+      LLDB_LOG_ERROR(log, bound_type_or_err.takeError(), "{0}");
+      return {};
+    }
+    static_type = *bound_type_or_err;
+  }
 
   auto stride = 0;
   auto opt_stride = static_type.GetByteStride(frame_sp.get());
diff --git a/lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.h b/lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.h
@@ -370,8 +370,8 @@ class SwiftLanguageRuntime : public LanguageRuntime {
   /// version of \p base_type that replaces all generic type
   /// parameters with bound generic types. If a generic type parameter
   /// cannot be resolved, the input type is returned.
-  CompilerType BindGenericTypeParameters(StackFrame &stack_frame,
-                                         CompilerType base_type);
+  llvm::Expected<CompilerType>
+  BindGenericTypeParameters(StackFrame &stack_frame, CompilerType base_type);
 
   bool IsStoredInlineInBuffer(CompilerType type) override;
 
@@ -591,13 +591,14 @@ class SwiftLanguageRuntime : public LanguageRuntime {
   GetRemoteASTContext(SwiftASTContext &swift_ast_ctx);
 
   /// Like \p BindGenericTypeParameters but for TypeSystemSwiftTypeRef.
-  CompilerType BindGenericTypeParameters(StackFrame &stack_frame,
-                                         TypeSystemSwiftTypeRef &ts,
-                                         ConstString mangled_name);
+  llvm::Expected<CompilerType>
+  BindGenericTypeParameters(StackFrame &stack_frame, TypeSystemSwiftTypeRef &ts,
+                            ConstString mangled_name);
 
   /// Like \p BindGenericTypeParameters but for RemoteAST.
-  CompilerType BindGenericTypeParametersRemoteAST(StackFrame &stack_frame,
-                                                  CompilerType base_type);
+  llvm::Expected<CompilerType>
+  BindGenericTypeParametersRemoteAST(StackFrame &stack_frame,
+                                     CompilerType base_type);
 
   bool GetDynamicTypeAndAddress_Pack(ValueObject &in_value,
                                      CompilerType pack_type,
diff --git a/lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeDynamicTypeResolution.cpp b/lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeDynamicTypeResolution.cpp
@@ -498,8 +498,10 @@ SwiftLanguageRuntime::GetMemberVariableOffsetRemoteMirrors(
   auto frame = instance ? instance->GetExecutionContextRef().GetFrameSP().get()
                         : nullptr;
   auto ti_or_err = GetSwiftRuntimeTypeInfo(instance_type, frame);
-  if (!ti_or_err)
+  if (!ti_or_err) {
     LLDB_LOG_ERRORV(GetLog(LLDBLog::Types), ti_or_err.takeError(), "{0}");
+    return {};
+  }
   auto *ti = &*ti_or_err;
   if (auto *rti =
           llvm::dyn_cast_or_null<swift::reflection::RecordTypeInfo>(ti)) {
@@ -2637,20 +2639,16 @@ CompilerType SwiftLanguageRuntime::BindGenericTypeParameters(
           unbound_type.GetMangledTypeName()));
 }
 
-CompilerType
+llvm::Expected<CompilerType>
 SwiftLanguageRuntime::BindGenericTypeParameters(StackFrame &stack_frame,
                                                 TypeSystemSwiftTypeRef &ts,
                                                 ConstString mangled_name) {
   LLDB_SCOPED_TIMER();
   using namespace swift::Demangle;
 
   ThreadSafeReflectionContext reflection_ctx = GetReflectionContext();
-  if (!reflection_ctx) {
-    LLDB_LOG(GetLog(LLDBLog::Expressions | LLDBLog::Types),
-             "No reflection context available.");
-    return ts.GetTypeFromMangledTypename(mangled_name);
-  }
-
+  if (!reflection_ctx)
+    return llvm::createStringError("no reflection context");
 
   ConstString func_name = stack_frame.GetSymbolContext(eSymbolContextFunction)
                               .GetFunctionName(Mangled::ePreferMangled);
@@ -2707,24 +2705,17 @@ SwiftLanguageRuntime::BindGenericTypeParameters(StackFrame &stack_frame,
   // Build a TypeRef from the demangle tree.
   auto type_ref_or_err =
       reflection_ctx->GetTypeRef(dem, canonical, ts.GetDescriptorFinder());
-  if (!type_ref_or_err) {
-    LLDB_LOG_ERROR(
-        GetLog(LLDBLog::Expressions | LLDBLog::Types),
-        type_ref_or_err.takeError(),
-        "Couldn't get type ref when binding generic type parameters: {0}");
-    return get_canonical();
-  }
+  if (!type_ref_or_err)
+    return llvm::joinErrors(
+        llvm::createStringError("cannot bind generic parameters"),
+        type_ref_or_err.takeError());
 
   // Apply the substitutions.
   auto bound_type_ref_or_err = reflection_ctx->ApplySubstitutions(
       *type_ref_or_err, substitutions, ts.GetDescriptorFinder());
-  if (!bound_type_ref_or_err) {
-    LLDB_LOG_ERROR(
-        GetLog(LLDBLog::Expressions | LLDBLog::Types),
-        bound_type_ref_or_err.takeError(),
-        "Couldn't get type ref when binding generic type parameters: {0}");
-    return get_canonical();
-  }
+  if (!bound_type_ref_or_err)
+    return bound_type_ref_or_err.takeError();
+
   NodePointer node = bound_type_ref_or_err->getDemangling(dem);
 
   // Import the type into the scratch context. Subsequent conversions
@@ -2736,29 +2727,24 @@ SwiftLanguageRuntime::BindGenericTypeParameters(StackFrame &stack_frame,
   // the original context as to resolve type aliases correctly.
   auto &target = GetProcess().GetTarget();
   auto scratch_ctx = TypeSystemSwiftTypeRefForExpressions::GetForTarget(target);
-  if (!scratch_ctx) {
-    LLDB_LOG(GetLog(LLDBLog::Expressions | LLDBLog::Types),
-             "No scratch context available.");
-    return ts.GetTypeFromMangledTypename(mangled_name);
-  }
+  if (!scratch_ctx)
+    return llvm::createStringError("No scratch context available.");
+
   CompilerType bound_type = scratch_ctx->RemangleAsType(dem, node, flavor);
   LLDB_LOG(GetLog(LLDBLog::Expressions | LLDBLog::Types), "Bound {0} -> {1}.",
            mangled_name, bound_type.GetMangledTypeName());
 
   if (generic_signature && generic_signature->HasPacks()) {
     auto bound_type_or_err = BindGenericPackType(stack_frame, bound_type);
-    if (!bound_type_or_err) {
-      LLDB_LOG_ERROR(GetLog(LLDBLog::Expressions | LLDBLog::Types),
-                     bound_type_or_err.takeError(), "{0}");
-      return bound_type;
-    }
+    if (!bound_type_or_err)
+      return bound_type_or_err.takeError();
     bound_type = *bound_type_or_err;
   }
 
   return bound_type;
 }
 
-CompilerType
+llvm::Expected<CompilerType>
 SwiftLanguageRuntime::BindGenericTypeParameters(StackFrame &stack_frame,
                                                 CompilerType base_type) {
   // If this is a TypeRef type, bind that.
@@ -3241,7 +3227,9 @@ bool SwiftLanguageRuntime::GetDynamicTypeAndAddress(
       if (!frame)
         return false;
 
-      bound_type = BindGenericTypeParameters(*frame.get(), val_type);
+      bound_type = llvm::expectedToOptional(
+                       BindGenericTypeParameters(*frame.get(), val_type))
+                       .value_or(CompilerType());
       if (!bound_type)
         return false;
     } else {
@@ -3495,7 +3483,10 @@ SwiftLanguageRuntime::GetSwiftRuntimeTypeInfo(
     if (StackFrame *frame = exe_scope->CalculateStackFrame().get()) {
       ExecutionContext exe_ctx;
       frame->CalculateExecutionContext(exe_ctx);
-      type = BindGenericTypeParameters(*frame, type);
+      auto bound_type_or_err = BindGenericTypeParameters(*frame, type);
+      if (!bound_type_or_err)
+        return bound_type_or_err.takeError();
+      type = *bound_type_or_err;
     }
 
   // BindGenericTypeParameters imports the type into the scratch
diff --git a/lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeNames.cpp b/lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeNames.cpp
@@ -694,9 +694,15 @@ void SwiftLanguageRuntime::GetGenericParameterNamesForFunction(
         break;
       CompilerType generic_type =
           ts->CreateGenericTypeParamType(depth, index, flavor);
-      CompilerType bound_type =
+      llvm::Expected<CompilerType> bound_type_or_err =
           runtime->BindGenericTypeParameters(*frame, generic_type);
-      type_name = bound_type.GetDisplayTypeName();
+      if (!bound_type_or_err) {
+        LLDB_LOG_ERROR(GetLog(LLDBLog::Expressions | LLDBLog::Types),
+                       bound_type_or_err.takeError(), "{0}");
+        break;
+      }
+
+      type_name = bound_type_or_err->GetDisplayTypeName();
       break;
     }
 
diff --git a/lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeRemoteAST.cpp b/lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntimeRemoteAST.cpp
@@ -132,7 +132,9 @@ std::optional<uint64_t> SwiftLanguageRuntime::GetMemberVariableOffsetRemoteAST(
     // Bind generic parameters if necessary.
     if (instance && swift_type->hasTypeParameter())
       if (auto *frame = instance->GetExecutionContextRef().GetFrameSP().get())
-        if (auto bound = BindGenericTypeParameters(*frame, instance_type)) {
+        if (auto bound = llvm::expectedToOptional(
+                             BindGenericTypeParameters(*frame, instance_type))
+                             .value_or(CompilerType())) {
           LLDB_LOGF(
               GetLog(LLDBLog::Types),
               "[MemberVariableOffsetResolver] resolved non-class type = %s",
@@ -265,7 +267,8 @@ SwiftLanguageRuntime::GetDynamicTypeAndAddress_ExistentialRemoteAST(
 }
 #endif
 
-CompilerType SwiftLanguageRuntime::BindGenericTypeParametersRemoteAST(
+llvm::Expected<CompilerType>
+SwiftLanguageRuntime::BindGenericTypeParametersRemoteAST(
     StackFrame &stack_frame, CompilerType base_type) {
   LLDB_SCOPED_TIMER();
 
diff --git a/lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.cpp b/lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.cpp
@@ -5863,7 +5863,9 @@ BindGenericTypeParameters(CompilerType type, ExecutionContextScope *exe_scope) {
     return type;
   ExecutionContext exe_ctx;
   exe_scope->CalculateExecutionContext(exe_ctx);
-  if (auto bound = runtime->BindGenericTypeParameters(*frame, type))
+  if (auto bound = llvm::expectedToOptional(
+                       runtime->BindGenericTypeParameters(*frame, type))
+                       .value_or(CompilerType()))
     return bound;
   return type;
 }
