Merge pull request #1098 from swiftwasm/swift/release/5.4

pull[bot] · web-flow · commit d8be2ea15500 · 2021-02-02T22:53:35.000Z
[pull] swiftwasm-release/5.4 from swift/release/5.4
diff --git a/lldb/include/lldb/Target/Process.h b/lldb/include/lldb/Target/Process.h
@@ -86,7 +86,6 @@ class ProcessProperties : public Properties {
   bool GetDetachKeepsStopped() const;
   void SetDetachKeepsStopped(bool keep_stopped);
   bool GetWarningsOptimization() const;
-  bool GetWarningsUnsupportedLanguage() const;
   bool GetStopOnExec() const;
   std::chrono::seconds GetUtilityExpressionTimeout() const;
   bool GetOSPluginReportsAllThreads() const;
@@ -394,7 +393,6 @@ class Process : public std::enable_shared_from_this<Process>,
   /// Process warning types.
   enum Warnings {
     eWarningsOptimization = 1,
-    eWarningsUnsupportedLanguage = 2,
     eWarningsSwiftImport
   };
 
@@ -1343,12 +1341,6 @@ class Process : public std::enable_shared_from_this<Process>,
   void PrintWarningCantLoadSwiftModule(const Module &module,
                                        std::string details);
 
-  /// Print a user-visible warning about a function written in a
-  /// language that this version of LLDB doesn't support.
-  ///
-  /// \see PrintWarningOptimization
-  void PrintWarningUnsupportedLanguage(const SymbolContext &sc);
-
   virtual bool GetProcessInfo(ProcessInstanceInfo &info);
 
   /// Get the exit status for a process.
diff --git a/lldb/source/Plugins/Language/Swift/SwiftLanguage.cpp b/lldb/source/Plugins/Language/Swift/SwiftLanguage.cpp
@@ -889,8 +889,15 @@ std::vector<ConstString> SwiftLanguage::GetPossibleFormattersMatches(
 
   const bool check_cpp = false;
   const bool check_objc = false;
-  bool canBeSwiftDynamic = compiler_type.IsPossibleDynamicType(
-      nullptr, check_cpp, check_objc);
+  bool canBeSwiftDynamic =
+      compiler_type.IsPossibleDynamicType(nullptr, check_cpp, check_objc) ||
+      // Foundation (but really any library) may create new
+      // Objective-C classes at runtime and LLDB's ObjC runtime
+      // implementation doesn't yet get notified about this. As a
+      // workaround we try to interpret ObjC id pointers as Swift
+      // classes to make them available.
+      (compiler_type.GetCanonicalType().GetTypeClass() ==
+       eTypeClassObjCObjectPointer);
 
   if (canBeSwiftDynamic) {
     do {
diff --git a/lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.cpp b/lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.cpp
@@ -4805,6 +4805,12 @@ CompilerType SwiftASTContext::GetErrorType() {
   return {};
 }
 
+CompilerType SwiftASTContext::GetObjCObjectType() {
+  // FIXME: ClangImporter::Implementation stores this type, but it's not
+  // exposed.
+  return GetCompilerType(ConstString("$sSo8NSObjectCD"));
+}
+
 SwiftASTContext *SwiftASTContext::GetSwiftASTContext(swift::ASTContext *ast) {
   SwiftASTContext *swift_ast = GetASTMap().Lookup(ast);
   return swift_ast;
diff --git a/lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.h b/lldb/source/Plugins/TypeSystem/Swift/SwiftASTContext.h
@@ -356,6 +356,7 @@ class SwiftASTContext : public TypeSystemSwift {
   CreateTupleType(const std::vector<TupleElement> &elements) override;
 
   CompilerType GetErrorType() override;
+  CompilerType GetObjCObjectType() override;
 
   bool HasErrors();
 
diff --git a/lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwift.h b/lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwift.h
@@ -116,6 +116,7 @@ class TypeSystemSwift : public TypeSystem {
   virtual bool IsImportedType(lldb::opaque_compiler_type_t type,
                               CompilerType *original_type) = 0;
   virtual CompilerType GetErrorType() = 0;
+  virtual CompilerType GetObjCObjectType() = 0;
   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;
diff --git a/lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.cpp b/lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.cpp
@@ -2755,6 +2755,23 @@ CompilerType TypeSystemSwiftTypeRef::GetErrorType() {
   VALIDATE_AND_RETURN_STATIC(impl, GetErrorType);
 }
 
+CompilerType TypeSystemSwiftTypeRef::GetObjCObjectType() {
+  auto impl = [&]() {
+    using namespace swift::Demangle;
+    Demangler dem;
+    auto *obj_type = dem.createNode(Node::Kind::Type);
+    NodePointer s = dem.createNode(Node::Kind::Structure);
+    NodePointer m =
+        dem.createNode(Node::Kind::Module, swift::MANGLING_MODULE_OBJC);
+    NodePointer ident = dem.createNode(Node::Kind::Identifier, "NSObject");
+    s->addChild(m, dem);
+    s->addChild(ident, dem);
+    obj_type->addChild(s, dem);
+    return RemangleAsType(dem, obj_type);
+  };
+  VALIDATE_AND_RETURN_STATIC(impl, GetObjCObjectType);
+}
+
 CompilerType
 TypeSystemSwiftTypeRef::GetReferentType(opaque_compiler_type_t type) {
   auto impl = [&]() -> CompilerType {
diff --git a/lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.h b/lldb/source/Plugins/TypeSystem/Swift/TypeSystemSwiftTypeRef.h
@@ -235,6 +235,7 @@ class TypeSystemSwiftTypeRef : public TypeSystemSwift {
   /// builtins (int <-> Swift.Int) as Clang types.
   CompilerType GetAsClangTypeOrNull(lldb::opaque_compiler_type_t type);
   CompilerType GetErrorType() override;
+  CompilerType GetObjCObjectType() override;
   CompilerType GetReferentType(lldb::opaque_compiler_type_t type) override;
   CompilerType GetInstanceType(lldb::opaque_compiler_type_t type) override;
   TypeAllocationStrategy
diff --git a/lldb/source/Target/Process.cpp b/lldb/source/Target/Process.cpp
@@ -259,12 +259,6 @@ bool ProcessProperties::GetWarningsOptimization() const {
       nullptr, idx, g_process_properties[idx].default_uint_value != 0);
 }
 
-bool ProcessProperties::GetWarningsUnsupportedLanguage() const {
-  const uint32_t idx = ePropertyWarningUnsupportedLanguage;
-  return m_collection_sp->GetPropertyAtIndexAsBoolean(
-      nullptr, idx, g_process_properties[idx].default_uint_value != 0);
-}
-
 bool ProcessProperties::GetStopOnExec() const {
   const uint32_t idx = ePropertyStopOnExec;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
@@ -5925,6 +5919,9 @@ void Process::PrintWarning(uint64_t warning_type, const void *repeat_key,
   StreamSP stream_sp = GetTarget().GetDebugger().GetAsyncOutputStream();
   if (!stream_sp)
     return;
+  if (warning_type == eWarningsOptimization && !GetWarningsOptimization()) {
+    return;
+  }
 
   if (repeat_key != nullptr) {
     WarningsCollection::iterator it = m_warnings_issued.find(warning_type);
@@ -5949,11 +5946,8 @@ void Process::PrintWarning(uint64_t warning_type, const void *repeat_key,
 }
 
 void Process::PrintWarningOptimization(const SymbolContext &sc) {
-  if (!GetWarningsOptimization())
-    return;
-  if (!sc.module_sp)
-    return;
-  if (!sc.module_sp->GetFileSpec().GetFilename().IsEmpty() && sc.function &&
+  if (GetWarningsOptimization() && sc.module_sp &&
+      !sc.module_sp->GetFileSpec().GetFilename().IsEmpty() && sc.function &&
       sc.function->GetIsOptimized()) {
     PrintWarning(Process::Warnings::eWarningsOptimization, sc.module_sp.get(),
                  "%s was compiled with optimization - stepping may behave "
@@ -5969,25 +5963,6 @@ void Process::PrintWarningCantLoadSwiftModule(const Module &module,
                module.GetFileSpec().GetCString(), details.c_str());
 }
 
-void Process::PrintWarningUnsupportedLanguage(const SymbolContext &sc) {
-  if (!GetWarningsUnsupportedLanguage())
-    return;
-  if (!sc.module_sp)
-    return;
-  LanguageType language = sc.GetLanguage();
-  if (language == eLanguageTypeUnknown)
-    return;
-  auto type_system_or_err = sc.module_sp->GetTypeSystemForLanguage(language);
-  if (auto err = type_system_or_err.takeError()) {
-    llvm::consumeError(std::move(err));
-    PrintWarning(Process::Warnings::eWarningsUnsupportedLanguage,
-                 sc.module_sp.get(),
-                 "This version of LLDB has no plugin for the %s language. "
-                 "Inspection of frame variables will be limited.\n",
-                 Language::GetNameForLanguageType(language));
-  }
-}
-
 bool Process::GetProcessInfo(ProcessInstanceInfo &info) {
   info.Clear();
 
diff --git a/lldb/source/Target/SwiftLanguageRuntimeDynamicTypeResolution.cpp b/lldb/source/Target/SwiftLanguageRuntimeDynamicTypeResolution.cpp
@@ -2486,7 +2486,8 @@ static bool CouldHaveDynamicValue(ValueObject &in_value) {
     // disable it.
     return !in_value.IsBaseClass();
   }
-  return var_type.IsPossibleDynamicType(nullptr, false, false);
+  bool check_objc = true;
+  return var_type.IsPossibleDynamicType(nullptr, false, check_objc);
 }
 
 bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress(
@@ -2497,10 +2498,6 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress(
   if (use_dynamic == lldb::eNoDynamicValues)
     return false;
 
-  // Try to import a Clang type into Swift.
-  if (in_value.GetObjectRuntimeLanguage() == eLanguageTypeObjC)
-    return GetDynamicTypeAndAddress_ClangType(
-        in_value, use_dynamic, class_type_or_name, address, value_type);
 
   if (!CouldHaveDynamicValue(in_value))
     return false;
@@ -2509,11 +2506,33 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress(
   // use the scratch context where such operations are legal and safe.
   assert(IsScratchContextLocked(in_value.GetTargetSP()) &&
          "Swift scratch context not locked ahead of dynamic type resolution");
+  CompilerType val_type(in_value.GetCompilerType());
+
   llvm::Optional<SwiftASTContextReader> maybe_scratch_ctx =
       in_value.GetScratchSwiftASTContext();
+
+  // Try to import a Clang type into Swift.
+  if (in_value.GetObjectRuntimeLanguage() == eLanguageTypeObjC) {
+    if (GetDynamicTypeAndAddress_ClangType(
+            in_value, use_dynamic, class_type_or_name, address, value_type))
+      return true;
+    // If the type couldn't be resolved by the Clang runtime:
+    // Foundation, for example, generates new Objective-C classes on
+    // the fly (such as instances of _DictionaryStorage<T1, T2>) and
+    // LLDB's ObjC runtime implementation isn't set up to recognize
+    // these. As a workaround, try to resolve them as Swift types.
+    if (val_type.GetCanonicalType().GetTypeClass() ==
+        eTypeClassObjCObjectPointer)
+      if (maybe_scratch_ctx)
+        if (auto *scratch_ctx = maybe_scratch_ctx->get())
+          val_type = scratch_ctx->GetObjCObjectType();
+  }
+
   if (!maybe_scratch_ctx)
     return false;
   SwiftASTContextForExpressions *scratch_ctx = maybe_scratch_ctx->get();
+  if (!scratch_ctx)
+    return false;
 
   auto retry_once = [&]() {
     // Retry exactly once using the per-module fallback scratch context.
@@ -2536,7 +2555,6 @@ bool SwiftLanguageRuntimeImpl::GetDynamicTypeAndAddress(
 
   // Import the type into the scratch context. Any form of dynamic
   // type resolution may trigger a cross-module import.
-  CompilerType val_type(in_value.GetCompilerType());
   Flags type_info(val_type.GetTypeInfo());
   if (!type_info.AnySet(eTypeIsSwift))
     return false;
diff --git a/lldb/source/Target/TargetProperties.td b/lldb/source/Target/TargetProperties.td
@@ -227,9 +227,6 @@ let Definition = "process" in {
   def WarningOptimization: Property<"optimization-warnings", "Boolean">,
     DefaultTrue,
     Desc<"If true, warn when stopped in code that is optimized where stepping and variable availability may not behave as expected.">;
-  def WarningUnsupportedLanguage: Property<"unsupported-language-warnings", "Boolean">,
-    DefaultTrue,
-    Desc<"If true, warn when stopped in code that is written in a source language that LLDB does not support.">;
   def StopOnExec: Property<"stop-on-exec", "Boolean">,
     Global,
     DefaultTrue,
diff --git a/lldb/source/Target/Thread.cpp b/lldb/source/Target/Thread.cpp
@@ -326,13 +326,10 @@ void Thread::FrameSelectedCallback(StackFrame *frame) {
   if (!frame)
     return;
 
-  if (frame->HasDebugInformation() &&
-      (GetProcess()->GetWarningsOptimization() ||
-       GetProcess()->GetWarningsUnsupportedLanguage())) {
+  if (frame->HasDebugInformation() && GetProcess()->GetWarningsOptimization()) {
     SymbolContext sc =
         frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextModule);
     GetProcess()->PrintWarningOptimization(sc);
-    GetProcess()->PrintWarningUnsupportedLanguage(sc);
   }
   SymbolContext msc = frame->GetSymbolContext(eSymbolContextModule);
   if (msc.module_sp)
diff --git a/lldb/test/Shell/Process/Inputs/true.c b/lldb/test/Shell/Process/Inputs/true.c
diff --git a/lldb/test/Shell/Process/Optimization.test b/lldb/test/Shell/Process/Optimization.test
diff --git a/lldb/test/Shell/Process/UnsupportedLanguage.test b/lldb/test/Shell/Process/UnsupportedLanguage.test
diff --git a/lldb/test/Shell/SwiftREPL/DictBridging.test b/lldb/test/Shell/SwiftREPL/DictBridging.test
@@ -67,7 +67,17 @@ let d_objc2 = NSArray(object: [1: 2] as [NSNumber: NSNumber] as NSDictionary)
 let d_objc3 = NSArray(object: [1: 2] as [Int: Int] as NSDictionary)
 // DICT-LABEL: d_objc3: NSArray = 1 element {
 // DICT-NEXT:    [0] = 1 key/value pair {
-// DICT-NEXT:      [0] = (key = 1, value = 2)
+//
+//               Allowing for both multi-line and single-line
+//               formatting, depending on CoreFoundation
+//               implementation:
+//
+// DICT-NOT: }
+// DICT:           [0] =
+// DICT-NOT: }
+// DICT:                 key = 1
+// DICT-NOT: }
+// DICT:                 value = 2
 // DICT-NEXT:    }
 // DICT-NEXT:  }
 
