Merge pull request #10059 from adrian-prantl/expr-fallback

[lldb] Allow SwiftASTContext fallbacks for types from expressions

Author: adrian-prantl

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

@@ -60,6 +60,25 @@ NodeAtPath(swift::Demangle::NodePointer root,
   return ChildAtPath(root, kind_path.drop_front());
 }
 
+/// Find the first child node of root that satisfies cond.
+inline swift::Demangle::NodePointer
+FindIf(swift::Demangle::NodePointer root,
+       std::function<bool(swift::Demangle::NodePointer)> cond) {
+  if (!root)
+    return nullptr;
+
+  auto *node = root;
+  if (cond(node))
+    return node;
+  for (auto *child : *node) {
+    assert(child && "swift::Demangle::Node has null child");
+    if (auto *found = FindIf(child, cond))
+      return found;
+  }
+
+  return nullptr;
+}
+
 /// \return the child of the TypeMangling node.
 static swift::Demangle::NodePointer
 GetTypeMangling(swift::Demangle::NodePointer n) {

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

@@ -1653,29 +1653,6 @@ swift::Demangle::NodePointer TypeSystemSwiftTypeRef::GetDemangleTreeForPrinting(
   return GetNodeForPrintingImpl(dem, node, flavor, resolve_objc_module);
 }
 
-/// Determine wether this demangle tree contains a node of kind \c kind and with
-/// text \c text (if provided).
-static bool Contains(swift::Demangle::NodePointer node,
-                     swift::Demangle::Node::Kind kind,
-                     llvm::StringRef text = "") {
-  if (!node)
-    return false;
-
-  if (node->getKind() == kind) {
-    if (text.empty())
-      return true;
-    if (!node->hasText())
-      return false;
-    return node->getText() == text;
-  }
-
-  for (swift::Demangle::NodePointer child : *node)
-    if (Contains(child, kind, text))
-      return true;
-
-  return false;
-}
-
 static bool ProtocolCompositionContainsSingleObjcProtocol(
     swift::Demangle::NodePointer node) {
   // Kind=ProtocolList
@@ -1691,12 +1668,18 @@ static bool ProtocolCompositionContainsSingleObjcProtocol(
       type_list->getNumChildren() != 1)
     return false;
   NodePointer type = type_list->getFirstChild();
-  return Contains(type, Node::Kind::Module, swift::MANGLING_MODULE_OBJC);
+  return swift_demangle::FindIf(type, [](NodePointer node) {
+    return node->getKind() == Node::Kind::Module && node->hasText() &&
+           node->getText() == swift::MANGLING_MODULE_OBJC;
+  });
 }
 
 /// Determine wether this demangle tree contains a generic type parameter.
 static bool ContainsGenericTypeParameter(swift::Demangle::NodePointer node) {
-  return Contains(node, swift::Demangle::Node::Kind::DependentGenericParamType);
+  return swift_demangle::FindIf(node, [](NodePointer node) {
+    return node->getKind() ==
+           swift::Demangle::Node::Kind::DependentGenericParamType;
+  });
 }
 
 /// Collect TypeInfo flags from a demangle tree. For most attributes
@@ -1929,7 +1912,9 @@ uint32_t TypeSystemSwiftTypeRef::CollectTypeInfo(
   if (swift_flags != eTypeIsSwift) {
     if (ContainsGenericTypeParameter(node))
       swift_flags |= eTypeHasUnboundGeneric;
-    if (Contains(node, Node::Kind::DynamicSelf))
+    if (swift_demangle::FindIf(node, [](NodePointer node) {
+          return node->getKind() == swift::Demangle::Node::Kind::DynamicSelf;
+        }))
       swift_flags |= eTypeHasDynamicSelf;
     return swift_flags;
   }
@@ -2817,6 +2802,8 @@ constexpr ExecutionContextScope *g_no_exe_ctx = nullptr;
 
 bool TypeSystemSwiftTypeRef::UseSwiftASTContextFallback(
     const char *func_name, lldb::opaque_compiler_type_t type) {
+  if (IsExpressionEvaluatorDefined(type))
+    return true;
   if (!ModuleList::GetGlobalModuleListProperties().GetSwiftTypeSystemFallback())
     return false;
 
@@ -2827,8 +2814,11 @@ bool TypeSystemSwiftTypeRef::UseSwiftASTContextFallback(
   return true;
 }
 
-bool TypeSystemSwiftTypeRef::DiagnoseSwiftASTContextFallback(
+void TypeSystemSwiftTypeRef::DiagnoseSwiftASTContextFallback(
     const char *func_name, lldb::opaque_compiler_type_t type) {
+  if (IsExpressionEvaluatorDefined(type))
+    return;
+
   const char *type_name = AsMangledName(type);
 
   std::optional<lldb::user_id_t> debugger_id;
@@ -2842,7 +2832,6 @@ bool TypeSystemSwiftTypeRef::DiagnoseSwiftASTContextFallback(
   Debugger::ReportWarning(msg, debugger_id, &m_fallback_warning);
 
   LLDB_LOGF(GetLog(LLDBLog::Types), "%s", msg.c_str());
-  return true;
 }
 
 CompilerType
@@ -2900,6 +2889,20 @@ TypeSystemSwiftTypeRef::DemangleCanonicalOutermostType(
   return canonical;
 }
 
+bool TypeSystemSwiftTypeRef::IsExpressionEvaluatorDefined(
+    lldb::opaque_compiler_type_t type) {
+  using namespace swift::Demangle;
+  const auto *mangled_name = AsMangledName(type);
+  Demangler dem;
+  NodePointer node = GetDemangledType(dem, mangled_name);
+  return swift_demangle::FindIf(node, [](NodePointer node) -> NodePointer {
+    if (node->getKind() == Node::Kind::Module &&
+        node->getText().starts_with("__lldb_expr"))
+      return node;
+    return nullptr;
+  });
+}
+
 CompilerType TypeSystemSwiftTypeRef::CreateGenericTypeParamType(
     unsigned int depth, unsigned int index,
     swift::Mangle::ManglingFlavor flavor) {

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

@@ -446,7 +446,7 @@ class TypeSystemSwiftTypeRef : public TypeSystemSwift {
   bool UseSwiftASTContextFallback(const char *func_name,
                                   lldb::opaque_compiler_type_t type);
   /// Print a warning that a fallback was necessary.
-  bool DiagnoseSwiftASTContextFallback(const char *func_name,
+  void DiagnoseSwiftASTContextFallback(const char *func_name,
                                        lldb::opaque_compiler_type_t type);
 
   /// Helper that creates an AST type from \p type.
@@ -544,6 +544,11 @@ class TypeSystemSwiftTypeRef : public TypeSystemSwift {
   swift::Demangle::NodePointer
   GetClangTypeTypeNode(swift::Demangle::Demangler &dem,
                        CompilerType clang_type);
+
+  /// Determine if this type contains a type from a module that looks
+  /// like it was JIT-compiled by LLDB.
+  bool IsExpressionEvaluatorDefined(lldb::opaque_compiler_type_t type);
+
 #ifndef NDEBUG
   /// Check whether the type being dealt with is tricky to validate due to
   /// discrepancies between TypeSystemSwiftTypeRef and SwiftASTContext.

lldb/test/API/lang/swift/expression/self/Makefile

@@ -1,6 +1,3 @@
 SWIFT_SOURCES := main.swift
 include Makefile.rules
 
-cleanup:
-	rm -f Makefile *.d
-