Add an is_pack flag to GenericSignature

Author: adrian-prantl

lldb/source/Plugins/LanguageRuntime/Swift/SwiftLanguageRuntime.h

@@ -281,6 +281,7 @@ class SwiftLanguageRuntime : public LanguageRuntime {
       /// A vector of |generic_params| bits, indicating which other
       /// generic_params share the same shape.
       llvm::BitVector same_shape;
+      bool is_pack = false;
       GenericParam(unsigned d, unsigned i, unsigned nparams)
           : depth(d), index(i), same_shape(nparams) {}
     };
@@ -294,11 +295,12 @@ class SwiftLanguageRuntime : public LanguageRuntime {
     };
 
     llvm::SmallVector<GenericParam, 4> generic_params;
-    /// Indices of the shape of the pack expansions.
     llvm::SmallVector<PackExpansion> pack_expansions;
 
     llvm::SmallVector<unsigned, 4> count_for_value_pack;
     llvm::SmallVector<unsigned, 4> count_for_type_pack;
+    unsigned dependent_generic_param_count = 0;
+    unsigned num_counts = 0;
 
     unsigned GetNumValuePacks() { return count_for_value_pack.size(); }
     unsigned GetNumTypePacks() { return count_for_type_pack.size(); }

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

@@ -677,9 +677,8 @@ void SwiftLanguageRuntime::GetGenericParameterNamesForFunction(
   }
 }
 
-std::string
-SwiftLanguageRuntime::DemangleSymbolAsString(StringRef symbol, DemangleMode mode,
-                                             const SymbolContext *sc) {
+std::string SwiftLanguageRuntime::DemangleSymbolAsString(
+    StringRef symbol, DemangleMode mode, const SymbolContext *sc) {
   bool did_init = false;
   llvm::DenseMap<ArchetypePath, StringRef> dict;
   swift::Demangle::DemangleOptions options;
@@ -1231,7 +1230,8 @@ SwiftLanguageRuntime::GetGenericSignature(StringRef function_name,
     if (child->getKind() ==
             swift::Demangle::Node::Kind::DependentGenericParamCount &&
         child->hasIndex()) {
-      if (child->getIndex() != num_generic_params)
+      signature.dependent_generic_param_count = child->getIndex();
+      if (signature.dependent_generic_param_count > num_generic_params)
         return {};
       continue;
     }
@@ -1331,12 +1331,24 @@ SwiftLanguageRuntime::GetGenericSignature(StringRef function_name,
         signature.count_for_type_pack.push_back(count);
 
     // Mark all pack_expansions with the same shape for skipping.
-    auto shape = signature.generic_params[shape_idx];
+    auto &shape = signature.generic_params[shape_idx];
     skip |= shape.same_shape;
   }
+  signature.num_counts = next_count;
   assert(signature.count_for_value_pack.size() ==
          signature.pack_expansions.size());
 
+  // Fill in the is_pack field for all generic parameters.
+  for (auto pack_expansion : signature.pack_expansions) {
+    unsigned shape_idx = pack_expansion.shape;
+    auto &param = signature.generic_params[shape_idx];
+    param.is_pack = true;
+    for (unsigned idx : param.same_shape.set_bits()) {
+      auto &sibling = signature.generic_params[idx];
+      sibling.is_pack = true;
+    }
+  }
+
   return signature;
 }
 

lldb/unittests/Symbol/TestTypeSystemSwiftTypeRef.cpp

@@ -930,6 +930,8 @@ TEST_F(TestTypeSystemSwiftTypeRef, GenericSignature) {
     ASSERT_EQ(s.GetNumTypePacks(), 1);
     ASSERT_EQ(s.GetCountForValuePack(0), 0);
     ASSERT_EQ(s.GetCountForTypePack(0), 0);
+    ASSERT_TRUE(s.generic_params[0].is_pack);
+    ASSERT_FALSE(s.generic_params[1].is_pack);
   }
   {
     // public func f6<U..., V...>(us: repeat each U, more_us: repeat each U, vs: repeat each V) {}
@@ -969,6 +971,45 @@ TEST_F(TestTypeSystemSwiftTypeRef, GenericSignature) {
     ASSERT_EQ(s.GetCountForValuePack(3), 1);
     ASSERT_EQ(s.GetCountForTypePack(0), 0);
     ASSERT_EQ(s.GetCountForTypePack(1), 1);
+    ASSERT_EQ(s.num_counts, 2);
   }
 
+  // Test non-variadic functions.
+  {
+    //public class C<U> {
+    //  public func f<V>(_ v: V) {}
+    //}
+    auto maybe_signature = SwiftLanguageRuntime::GetGenericSignature(
+        "$s1t1CC1fyyqd__lF", *m_swift_ts);
+    ASSERT_TRUE(maybe_signature.hasValue());
+    auto s = *maybe_signature;
+    // "U" does not count.
+    ASSERT_EQ(s.dependent_generic_param_count, 1);
+    ASSERT_EQ(s.generic_params.size(), 1);
+    ASSERT_EQ(s.pack_expansions.size(), 0);
+    ASSERT_EQ(s.GetNumValuePacks(), 0);
+    ASSERT_EQ(s.GetNumTypePacks(), 0);
+  }
+  // Test non-variadic functions.
+  {
+    //public class C<U> {
+    //  public func f<V>(_ u: U, _ v: V) {}
+    //}
+    auto maybe_signature = SwiftLanguageRuntime::GetGenericSignature(
+        "$s1t1CC1fyyx_qd__tlF", *m_swift_ts);
+    ASSERT_TRUE(maybe_signature.hasValue());
+    auto s = *maybe_signature;
+    ASSERT_EQ(s.dependent_generic_param_count, 1);
+    ASSERT_EQ(s.generic_params.size(), 2);
+    ASSERT_EQ(s.pack_expansions.size(), 0);
+    ASSERT_EQ(s.GetNumValuePacks(), 0);
+    ASSERT_EQ(s.GetNumTypePacks(), 0);
+  }
+  // Test a non-generic function.
+  {
+    // public func f() {}
+    auto maybe_signature = SwiftLanguageRuntime::GetGenericSignature(
+        "$s1t1fyyF", *m_swift_ts);
+    ASSERT_FALSE(maybe_signature.hasValue());
+  }
 }