Merge pull request #7262 from adrian-prantl/113997661-swiftself-5.9

Avoid a roundtrip through SwiftASTContext in findSwiftSelf() (NFC)

Author: adrian-prantl

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

@@ -115,10 +115,7 @@ struct SwiftSelfInfo {
 
   /// Adjusted type of `self`. If we're in a static method, this is an instance
   /// type.
-  CompilerType type = {};
-
-  /// Underlying Swift type for the adjusted type of `self`.
-  swift::TypeBase *swift_type = nullptr;
+  CompilerType type;
 
   /// Type flags for the adjusted type of `self`.
   Flags type_flags = {};
@@ -143,7 +140,7 @@ findSwiftSelf(StackFrame &frame, lldb::VariableSP self_var_sp) {
 
   // 3) If (1) and (2) fail, give up.
   if (!info.type.IsValid())
-    return llvm::None;
+    return {};
 
   // 4) If `self` is a metatype, get its instance type.
   if (Flags(info.type.GetTypeInfo())
@@ -152,20 +149,15 @@ findSwiftSelf(StackFrame &frame, lldb::VariableSP self_var_sp) {
     info.is_metatype = true;
   }
 
-  info.swift_type = GetSwiftType(info.type).getPointer();
-  if (auto *dyn_self =
-          llvm::dyn_cast_or_null<swift::DynamicSelfType>(info.swift_type))
-    info.swift_type = dyn_self->getSelfType().getPointer();
-
-  // 5) If the adjusted type isn't equal to the type according to the runtime,
-  // switch it to the latter type.
-  if (info.swift_type && (info.swift_type != info.type.GetOpaqueQualType()))
-    info.type = ToCompilerType(info.swift_type);
+  auto ts = info.type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>();
+  if (!ts)
+    return {};
+  info.type = ts->GetStaticSelfType(info.type.GetOpaqueQualType());
 
   info.type_flags = Flags(info.type.GetTypeInfo());
 
   if (!info.type.IsValid())
-    return llvm::None;
+    return {};
   return info;
 }
 
@@ -255,12 +247,18 @@ void SwiftUserExpression::ScanContext(ExecutionContext &exe_ctx, Status &err) {
     m_is_class |= info.type_flags.Test(lldb::eTypeIsClass);
 
   // Handle weak self.
-  auto *ref_type =
-      llvm::dyn_cast_or_null<swift::ReferenceStorageType>(info.swift_type);
-  if (ref_type && ref_type->getOwnership() == swift::ReferenceOwnership::Weak) {
-    m_is_class = true;
-    m_is_weak_self = true;
-  }
+
+  auto ts = info.type.GetTypeSystem().dyn_cast_or_null<TypeSystemSwift>();
+  if (!ts)
+    return;
+
+  if (auto ownership_kind = ts->GetNonTriviallyManagedReferenceKind(
+          info.type.GetOpaqueQualType()))
+    if (*ownership_kind ==
+        SwiftASTContext::NonTriviallyManagedReferenceKind::eWeak) {
+      m_is_class = true;
+      m_is_weak_self = true;
+    }
 
   m_needs_object_ptr = !m_in_static_method;
 

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

@@ -2442,20 +2442,9 @@ SwiftLanguageRuntimeImpl::BindGenericTypeParameters(StackFrame &stack_frame,
   }
 
   Demangler dem;
-  NodePointer canonical = TypeSystemSwiftTypeRef::Transform(
-      dem, dem.demangleSymbol(mangled_name.GetStringRef()),
-      [](NodePointer node) {
-        if (node->getKind() != Node::Kind::DynamicSelf)
-          return node;
-        // Substitute the static type for dynamic self.
-        assert(node->getNumChildren() == 1);
-        if (node->getNumChildren() != 1)
-          return node;
-        NodePointer type = node->getChild(0);
-        if (type->getKind() != Node::Kind::Type || type->getNumChildren() != 1)
-          return node;
-        return type->getChild(0);
-      });
+
+  NodePointer canonical = TypeSystemSwiftTypeRef::GetStaticSelfType(
+      dem, dem.demangleSymbol(mangled_name.GetStringRef()));
 
   // Build the list of type substitutions.
   swift::reflection::GenericArgumentMap substitutions;

lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.cpp

@@ -5166,6 +5166,17 @@ CompilerType SwiftASTContext::GetReferentType(opaque_compiler_type_t type) {
   return ToCompilerType({ref_type});
 }
 
+CompilerType
+SwiftASTContext::GetStaticSelfType(lldb::opaque_compiler_type_t type) {
+  VALID_OR_RETURN_CHECK_TYPE(type, CompilerType());
+
+  swift::Type swift_type = GetSwiftType(type);
+  if (auto *dyn_self =
+          llvm::dyn_cast_or_null<swift::DynamicSelfType>(swift_type))
+    return ToCompilerType({dyn_self->getSelfType().getPointer()});
+  return {weak_from_this(), type};
+}
+
 bool SwiftASTContext::IsFullyRealized(const CompilerType &compiler_type) {
   if (swift::CanType swift_can_type = ::GetCanonicalSwiftType(compiler_type)) {
     if (swift::isa<swift::MetatypeType>(swift_can_type))

lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.h

@@ -806,6 +806,7 @@ class SwiftASTContext : public TypeSystemSwift {
                       CompilerType *original_type) override;
 
   CompilerType GetReferentType(lldb::opaque_compiler_type_t type) override;
+  CompilerType GetStaticSelfType(lldb::opaque_compiler_type_t type) override;
 
   /// Retrieve/import the modules imported by the compilation
   /// unit. Early-exists with false if there was an import failure.

lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwift.h

@@ -128,6 +128,8 @@ class TypeSystemSwift : public TypeSystem {
   virtual CompilerType GetReferentType(lldb::opaque_compiler_type_t type) = 0;
   static CompilerType GetInstanceType(CompilerType ct);
   virtual CompilerType GetInstanceType(lldb::opaque_compiler_type_t type) = 0;
+  /// Return the static type if this is a DynamicSelf type else the input type.
+  virtual CompilerType GetStaticSelfType(lldb::opaque_compiler_type_t type) = 0;
   enum class TypeAllocationStrategy { eInline, ePointer, eDynamic, eUnknown };
   struct TupleElement {
     ConstString element_name;

lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.cpp

@@ -3429,6 +3429,38 @@ TypeSystemSwiftTypeRef::GetReferentType(opaque_compiler_type_t type) {
                       (ReconstructType(type)), (ReconstructType(type)));
 }
 
+swift::Demangle::NodePointer
+TypeSystemSwiftTypeRef::GetStaticSelfType(swift::Demangle::Demangler &dem,
+                                          swift::Demangle::NodePointer node) {
+  using namespace swift::Demangle;
+  return TypeSystemSwiftTypeRef::Transform(dem, node, [](NodePointer node) {
+    if (node->getKind() != Node::Kind::DynamicSelf)
+      return node;
+    // Substitute the static type for dynamic self.
+    assert(node->getNumChildren() == 1);
+    if (node->getNumChildren() != 1)
+      return node;
+    NodePointer type = node->getChild(0);
+    if (type->getKind() != Node::Kind::Type || type->getNumChildren() != 1)
+      return node;
+    return type->getChild(0);
+  });
+}
+
+CompilerType
+TypeSystemSwiftTypeRef::GetStaticSelfType(lldb::opaque_compiler_type_t type) {
+  auto impl = [&]() -> CompilerType {
+    using namespace swift::Demangle;
+    Demangler dem;
+    NodePointer node = GetDemangledType(dem, AsMangledName(type));
+    auto *type_node = dem.createNode(Node::Kind::Type);
+    type_node->addChild(GetStaticSelfType(dem, node), dem);
+    return RemangleAsType(dem, type_node);
+  };
+  VALIDATE_AND_RETURN(impl, GetStaticSelfType, type, g_no_exe_ctx,
+                      (ReconstructType(type)), (ReconstructType(type)));
+}
+
 CompilerType
 TypeSystemSwiftTypeRef::GetInstanceType(opaque_compiler_type_t type) {
   auto impl = [&]() -> CompilerType {

lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.h

@@ -271,6 +271,11 @@ class TypeSystemSwiftTypeRef : public TypeSystemSwift {
   CompilerType GetErrorType() override;
   CompilerType GetReferentType(lldb::opaque_compiler_type_t type) override;
   CompilerType GetInstanceType(lldb::opaque_compiler_type_t type) override;
+  CompilerType GetStaticSelfType(lldb::opaque_compiler_type_t type) override;
+  static swift::Demangle::NodePointer
+  GetStaticSelfType(swift::Demangle::Demangler &dem,
+                    swift::Demangle::NodePointer node);
+
   /// Wrap type inside a SILPackType.
   CompilerType CreateSILPackType(CompilerType type, bool indirect);
   struct PackTypeInfo {