ASTDemangler: Pass down a generic signature so that we can reconstruct pack generic parameters

Author: slavapestov

include/swift/AST/ASTDemangler.h

@@ -37,13 +37,16 @@ namespace Demangle {
 SWIFT_BEGIN_INLINE_NAMESPACE
 
 Type getTypeForMangling(ASTContext &ctx,
-                        llvm::StringRef mangling);
+                        llvm::StringRef mangling,
+                        GenericSignature genericSig=GenericSignature());
 
 TypeDecl *getTypeDeclForMangling(ASTContext &ctx,
-                                 llvm::StringRef mangling);
+                                 llvm::StringRef mangling,
+                                 GenericSignature genericSig=GenericSignature());
 
 TypeDecl *getTypeDeclForUSR(ASTContext &ctx,
-                            llvm::StringRef usr);
+                            llvm::StringRef usr,
+                            GenericSignature genericSig=GenericSignature());
 
 /// An implementation of MetadataReader's BuilderType concept that
 /// just finds and builds things in the AST.
@@ -55,6 +58,11 @@ class ASTBuilder {
   /// Created lazily.
   DeclContext *NotionalDC = nullptr;
 
+  /// The generic signature for interpreting type parameters. This is used
+  /// because the mangling for a type parameter doesn't record whether it
+  /// is a pack or not, so we have to find it here.
+  GenericSignature GenericSig;
+
 public:
   using BuiltType = swift::Type;
   using BuiltTypeDecl = swift::GenericTypeDecl *; // nominal or type alias
@@ -66,7 +74,8 @@ class ASTBuilder {
 
   static constexpr bool needsToPrecomputeParentGenericContextShapes = false;
 
-  explicit ASTBuilder(ASTContext &ctx) : Ctx(ctx) {}
+  explicit ASTBuilder(ASTContext &ctx, GenericSignature genericSig)
+    : Ctx(ctx), GenericSig(genericSig) {}
 
   ASTContext &getASTContext() { return Ctx; }
   DeclContext *getNotionalDC();

lib/AST/ASTDemangler.cpp

@@ -38,36 +38,39 @@
 using namespace swift;
 
 Type swift::Demangle::getTypeForMangling(ASTContext &ctx,
-                                         StringRef mangling) {
+                                         StringRef mangling,
+                                         GenericSignature genericSig) {
   Demangle::Context Dem;
   auto node = Dem.demangleSymbolAsNode(mangling);
   if (!node)
     return Type();
 
-  ASTBuilder builder(ctx);
+  ASTBuilder builder(ctx, genericSig);
   return builder.decodeMangledType(node);
 }
 
 TypeDecl *swift::Demangle::getTypeDeclForMangling(ASTContext &ctx,
-                                                  StringRef mangling) {
+                                                  StringRef mangling,
+                                                  GenericSignature genericSig) {
   Demangle::Context Dem;
   auto node = Dem.demangleSymbolAsNode(mangling);
   if (!node)
     return nullptr;
 
-  ASTBuilder builder(ctx);
+  ASTBuilder builder(ctx, genericSig);
   return builder.createTypeDecl(node);
 }
 
 TypeDecl *swift::Demangle::getTypeDeclForUSR(ASTContext &ctx,
-                                             StringRef usr) {
+                                             StringRef usr,
+                                             GenericSignature genericSig) {
   if (!usr.startswith("s:"))
     return nullptr;
 
   std::string mangling(usr);
   mangling.replace(0, 2, MANGLING_PREFIX_STR);
 
-  return getTypeDeclForMangling(ctx, mangling);
+  return getTypeDeclForMangling(ctx, mangling, genericSig);
 }
 
 Type ASTBuilder::decodeMangledType(NodePointer node, bool forRequirement) {
@@ -683,7 +686,23 @@ Type ASTBuilder::createMetatypeType(Type instance,
 
 Type ASTBuilder::createGenericTypeParameterType(unsigned depth,
                                                 unsigned index) {
-  return GenericTypeParamType::get(/*isParameterPack*/ false, depth, index, Ctx);
+  // If we have a generic signature, find the parameter with the matching
+  // depth and index and return it, to get the correct value for the
+  // isParameterPack() bit.
+  if (GenericSig) {
+    for (auto paramTy : GenericSig.getGenericParams()) {
+      if (paramTy->getDepth() == depth && paramTy->getIndex() == index) {
+        return paramTy;
+      }
+    }
+
+    return Type();
+  }
+
+  // Otherwise, just assume we're not working with variadic generics.
+  // FIXME: Should we always require a generic signature in this case?
+  return GenericTypeParamType::get(/*isParameterPack*/ false,
+                                   depth, index, Ctx);
 }
 
 Type ASTBuilder::createDependentMemberType(StringRef member,
@@ -973,6 +992,13 @@ LayoutConstraint ASTBuilder::getLayoutConstraintWithSizeAlign(
 CanGenericSignature ASTBuilder::demangleGenericSignature(
     NominalTypeDecl *nominalDecl,
     NodePointer node) {
+  // The type parameters appearing in the signature's requirements are not
+  // notionally part of our current generic signature.
+  //
+  // FIXME: Fix this to support variadic generics.
+  llvm::SaveAndRestore<GenericSignature> savedSignature(
+      GenericSig, GenericSignature());
+
   SmallVector<Requirement, 2> requirements;
 
   decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,

lib/IRGen/IRGenDebugInfo.cpp

@@ -907,11 +907,13 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
         !Ty->getASTContext().LangOpts.EnableCXXInterop) {
       // Make sure we can reconstruct mangled types for the debugger.
       auto &Ctx = Ty->getASTContext();
-      Type Reconstructed = Demangle::getTypeForMangling(Ctx, Result);
+      Type Reconstructed = Demangle::getTypeForMangling(Ctx, Result, Sig);
       if (!Reconstructed) {
         llvm::errs() << "Failed to reconstruct type for " << Result << "\n";
         llvm::errs() << "Original type:\n";
         Ty->dump(llvm::errs());
+        if (Sig)
+          llvm::errs() << "Generic signature: " << Sig << "\n";
         abort();
       } else if (!Reconstructed->isEqual(Ty) &&
                  // FIXME: Some existential types are reconstructed without
@@ -924,6 +926,8 @@ class IRGenDebugInfoImpl : public IRGenDebugInfo {
         Ty->dump(llvm::errs());
         llvm::errs() << "Reconstructed type:\n";
         Reconstructed->dump(llvm::errs());
+        if (Sig)
+          llvm::errs() << "Generic signature: " << Sig << "\n";
         abort();
       }
     }

lib/RemoteAST/RemoteAST.cpp

@@ -432,7 +432,7 @@ class RemoteASTContextConcreteImpl final : public RemoteASTContextImpl {
 public:
   RemoteASTContextConcreteImpl(std::shared_ptr<MemoryReader> &&reader,
                                ASTContext &ctx)
-    : Reader(std::move(reader), ctx) {}
+    : Reader(std::move(reader), ctx, GenericSignature()) {}
 
   Result<Type> getTypeForRemoteTypeMetadata(RemoteAddress metadata,
                                             bool skipArtificial) override {

lib/Sema/TypeCheckType.cpp

@@ -3478,7 +3478,7 @@ TypeResolver::resolveOpaqueReturnType(TypeRepr *repr, StringRef mangledName,
   }
   if (definingDeclNode->getKind() == Node::Kind::Global)
     definingDeclNode = definingDeclNode->getChild(0);
-  ASTBuilder builder(getASTContext());
+  ASTBuilder builder(getASTContext(), GenericSignature());
   auto opaqueNode =
     builder.getNodeFactory().createNode(Node::Kind::OpaqueReturnTypeOf);
   opaqueNode->addChild(definingDeclNode, builder.getNodeFactory());

test/DebugInfo/constrained_extension.swift

@@ -0,0 +1,14 @@
+// RUN: %target-swift-frontend -emit-ir -g %s
+
+// Make sure we don't get the generic signature of the extension
+// (<T, U where T: Equatable, U: Equatable>) mixed up with the
+// generic signature of our function foo() (<T where T: Equatable>).
+
+public struct G<T, U> {}
+
+extension G where T: Equatable, U: Equatable {
+  public struct Nested {}
+}
+
+public func foo<T>(_: G<T, T>.Nested) {
+}