Explicitly represent "pseudo-generic" functions in SIL, which do (#2821)

not have access to their type arguments at runtime.  Use this to
fix the emission of native thunks for imported ObjC-generic
initializers, since they may need to perform bridging.

For now, pseudo-genericity is all-or-nothing, but we may want to
make it apply only to certain type arguments.

Also, clean up some code that was using dead mangling nodes.

Author: rjmccall

docs/ABI.rst

@@ -1016,6 +1016,7 @@ mangled in to disambiguate.
   impl-function-attribute ::= 'Cw'            // compatible with protocol witness
   impl-function-attribute ::= 'N'             // noreturn
   impl-function-attribute ::= 'G'             // generic
+  impl-function-attribute ::= 'g'             // pseudogeneric
   impl-parameter ::= impl-convention type
   impl-result ::= impl-convention type
 
@@ -1025,7 +1026,8 @@ implementation details of a function type.
 
 Any ``<impl-function-attribute>`` productions must appear in the order
 in which they are specified above: e.g. a noreturn C function is
-mangled with ``CcN``.
+mangled with ``CcN``.  ``g`` and ``G`` are exclusive and mark the presence
+of a generic signature immediately following.
 
 Note that the convention and function-attribute productions do not
 need to be disambiguated from the start of a ``<type>``.

include/swift/AST/Attr.def

@@ -57,6 +57,7 @@ TYPE_ATTR(callee_guaranteed)
 TYPE_ATTR(objc_metatype)
 TYPE_ATTR(opened)
 TYPE_ATTR(deallocating)
+TYPE_ATTR(pseudogeneric)
 
 // SIL metatype attributes.
 TYPE_ATTR(thin)

include/swift/AST/Types.h

@@ -2880,11 +2880,12 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
     // you'll need to adjust both the Bits field below and
     // BaseType::AnyFunctionTypeBits.
 
-    //   |representation|noReturn|
-    //   |    0 .. 3    |   4    |
+    //   |representation|noReturn|pseudogeneric|
+    //   |    0 .. 3    |   4    |      5      |
     //
     enum : uint16_t { RepresentationMask = 0x00F };
     enum : uint16_t { NoReturnMask       = 0x010 };
+    enum : uint16_t { PseudogenericMask  = 0x020 };
 
     uint16_t Bits;
 
@@ -2897,12 +2898,20 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
     ExtInfo() : Bits(0) { }
 
     // Constructor for polymorphic type.
-    ExtInfo(Representation Rep, bool IsNoReturn) {
-      Bits = ((unsigned) Rep) |
-             (IsNoReturn ? NoReturnMask : 0);
+    ExtInfo(Representation rep, bool isNoReturn, bool isPseudogeneric) {
+      Bits = ((unsigned) rep) |
+             (isNoReturn ? NoReturnMask : 0) |
+             (isPseudogeneric ? PseudogenericMask : 0);
     }
 
+    /// Is this function pseudo-generic?  A pseudo-generic function
+    /// is not permitted to dynamically depend on its type arguments.
+    bool isPseudogeneric() const { return Bits & PseudogenericMask; }
+
+    /// Do functions of this type return normally?
     bool isNoReturn() const { return Bits & NoReturnMask; }
+
+    /// What is the abstract representation of this function value?
     Representation getRepresentation() const {
       return Representation(Bits & RepresentationMask);
     }
@@ -2965,6 +2974,12 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
       else
         return ExtInfo(Bits & ~NoReturnMask);
     }
+    ExtInfo withIsPseudogeneric(bool isPseudogeneric = true) const {
+      if (isPseudogeneric)
+        return ExtInfo(Bits | PseudogenericMask);
+      else
+        return ExtInfo(Bits & ~PseudogenericMask);
+    }
 
     uint16_t getFuncAttrKey() const {
       return Bits;
@@ -3208,6 +3223,10 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
     return getExtInfo().isNoReturn();
   }
 
+  bool isPseudogeneric() const {
+    return getExtInfo().isPseudogeneric();
+  }
+
   CanSILFunctionType substGenericArgs(SILModule &silModule,
                                       ModuleDecl *astModule,
                                       ArrayRef<Substitution> subs);

include/swift/Basic/DemangleNodes.def

@@ -44,13 +44,14 @@ CONTEXT_NODE(Deallocator)
 NODE(DeclContext)
 CONTEXT_NODE(DefaultArgumentInitializer)
 NODE(DependentAssociatedTypeRef)
-NODE(DependentGenericSignature)
-NODE(DependentGenericParamCount)
 NODE(DependentGenericConformanceRequirement)
+NODE(DependentGenericParamCount)
+NODE(DependentGenericParamType)
 NODE(DependentGenericSameTypeRequirement)
+NODE(DependentGenericSignature)
 NODE(DependentGenericType)
 NODE(DependentMemberType)
-NODE(DependentGenericParamType)
+NODE(DependentPseudogenericSignature)
 CONTEXT_NODE(Destructor)
 CONTEXT_NODE(DidSet)
 NODE(Directness)
@@ -70,13 +71,11 @@ NODE(FunctionSignatureSpecializationParam)
 NODE(FunctionSignatureSpecializationParamKind)
 NODE(FunctionSignatureSpecializationParamPayload)
 NODE(FunctionType)
-NODE(Generics)
 NODE(GenericProtocolWitnessTable)
 NODE(GenericProtocolWitnessTableInstantiationFunction)
 NODE(GenericSpecialization)
 NODE(GenericSpecializationNotReAbstracted)
 NODE(GenericSpecializationParam)
-NODE(GenericType)
 NODE(GenericTypeMetadataPattern)
 CONTEXT_NODE(Getter)
 NODE(Global)

include/swift/Serialization/ModuleFormat.h

@@ -53,7 +53,7 @@ const uint16_t VERSION_MAJOR = 0;
 /// in source control, you should also update the comment to briefly
 /// describe what change you made. The content of this comment isn't important;
 /// it just ensures a conflict if two people change the module format.
-const uint16_t VERSION_MINOR = 249; // Last change: SIL clang decls
+const uint16_t VERSION_MINOR = 250; // Last change: SILFunctionType::isPseudogeneric
 
 using DeclID = PointerEmbeddedInt<unsigned, 31>;
 using DeclIDField = BCFixed<31>;
@@ -702,6 +702,7 @@ namespace decls_block {
     ParameterConventionField, // callee convention
     SILFunctionTypeRepresentationField, // representation
     BCFixed<1>,            // noreturn?
+    BCFixed<1>,            // pseudogeneric?
     BCFixed<1>,            // error result?
     BCFixed<30>,           // number of parameters
     BCFixed<30>,           // number of results

lib/AST/ASTPrinter.cpp

@@ -3721,6 +3721,9 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       }
     }
 
+    if (info.isPseudogeneric())
+      Printer << "@pseudogeneric ";
+
     if (info.isNoReturn())
       Printer << "@noreturn ";
   }

lib/AST/Mangle.cpp

@@ -1125,6 +1125,7 @@ void Mangler::mangleType(Type type, unsigned uncurryLevel) {
     // <impl-function-attribute> ::= 'Cm'             // Swift method
     // <impl-function-attribute> ::= 'CO'             // ObjC method
     // <impl-function-attribute> ::= 'N'              // noreturn
+    // <impl-function-attribute> ::= 'g'              // pseudogeneric
     // <impl-function-attribute> ::= 'G'              // generic
     // <impl-parameter> ::= <impl-convention> <type>
     // <impl-result> ::= <impl-convention> <type>
@@ -1188,7 +1189,7 @@ void Mangler::mangleType(Type type, unsigned uncurryLevel) {
 
     if (fn->isNoReturn()) Buffer << 'N';
     if (fn->isPolymorphic()) {
-      Buffer << 'G';
+      Buffer << (fn->isPseudogeneric() ? 'g' : 'G');
       mangleGenericSignature(fn->getGenericSignature());
     }
     Buffer << '_';

lib/Basic/Demangle.cpp

@@ -1514,8 +1514,11 @@ class Demangler {
     return nodeType;
   }
 
-  NodePointer demangleGenericSignature() {
-    auto sig = NodeFactory::create(Node::Kind::DependentGenericSignature);
+  NodePointer demangleGenericSignature(bool isPseudogeneric = false) {
+    auto sig =
+      NodeFactory::create(isPseudogeneric
+                            ? Node::Kind::DependentPseudogenericSignature
+                            : Node::Kind::DependentGenericSignature);
     // First read in the parameter counts at each depth.
     Node::IndexType count = ~(Node::IndexType)0;
 
@@ -2106,8 +2109,10 @@ class Demangler {
 
     // Enter a new generic context if this type is generic.
     // FIXME: replace with std::optional, when we have it.
-    if (Mangled.nextIf('G')) {
-      NodePointer generics = demangleGenericSignature();
+    bool isPseudogeneric = false;
+    if (Mangled.nextIf('G') ||
+        (isPseudogeneric = Mangled.nextIf('g'))) {
+      NodePointer generics = demangleGenericSignature(isPseudogeneric);
       if (!generics)
         return nullptr;
       type->addChild(generics);
@@ -2382,6 +2387,7 @@ class NodePrinter {
     case Node::Kind::DependentGenericParamCount:
     case Node::Kind::DependentGenericConformanceRequirement:
     case Node::Kind::DependentGenericSameTypeRequirement:
+    case Node::Kind::DependentPseudogenericSignature:
     case Node::Kind::Destructor:
     case Node::Kind::DidSet:
     case Node::Kind::DirectMethodReferenceAttribute:
@@ -2397,13 +2403,11 @@ class NodePrinter {
     case Node::Kind::FunctionSignatureSpecializationParamKind:
     case Node::Kind::FunctionSignatureSpecializationParamPayload:
     case Node::Kind::FunctionType:
-    case Node::Kind::Generics:
     case Node::Kind::GenericProtocolWitnessTable:
     case Node::Kind::GenericProtocolWitnessTableInstantiationFunction:
     case Node::Kind::GenericSpecialization:
     case Node::Kind::GenericSpecializationNotReAbstracted:
     case Node::Kind::GenericSpecializationParam:
-    case Node::Kind::GenericType:
     case Node::Kind::GenericTypeMetadataPattern:
     case Node::Kind::Getter:
     case Node::Kind::Global:
@@ -2783,8 +2787,7 @@ static bool useColonForEntityType(NodePointer entity, NodePointer type) {
   case Node::Kind::IVarDestroyer: {
     // We expect to see a function type here, but if we don't, use the colon.
     type = type->getChild(0);
-    while (type->getKind() == Node::Kind::GenericType ||
-           type->getKind() == Node::Kind::DependentGenericType)
+    while (type->getKind() == Node::Kind::DependentGenericType)
       type = type->getChild(1)->getChild(0);
     return (type->getKind() != Node::Kind::FunctionType &&
             type->getKind() != Node::Kind::UncurriedFunctionType &&
@@ -2822,8 +2825,7 @@ void NodePrinter::printSimplifiedEntityType(NodePointer context,
   type = type->getChild(0);
 
   NodePointer generics;
-  if (type->getKind() == Node::Kind::GenericType ||
-      type->getKind() == Node::Kind::DependentGenericType) {
+  if (type->getKind() == Node::Kind::DependentGenericType) {
     generics = type->getChild(0);
     type = type->getChild(1)->getChild(0);
   }
@@ -3430,20 +3432,6 @@ void NodePrinter::print(NodePointer pointer, bool asContext, bool suppressType)
       Printer << ">";
     return;
   }
-  case Node::Kind::Generics: {
-    if (pointer->getNumChildren() == 0)
-      return;
-    Printer << "<";
-    print(pointer->getChild(0));
-    for (unsigned i = 1, e = pointer->getNumChildren(); i != e; ++i) {
-      auto child = pointer->getChild(i);
-      if (child->getKind() != Node::Kind::Archetype) break;
-      Printer << ", ";
-      print(child);
-    }
-    Printer << ">";
-    return;
-  }
   case Node::Kind::Archetype: {
     Printer << pointer->getText();
     if (pointer->hasChildren()) {
@@ -3469,13 +3457,6 @@ void NodePrinter::print(NodePointer pointer, bool asContext, bool suppressType)
     Printer << ")";
     return;
   }
-  case Node::Kind::GenericType: {
-    NodePointer atype_list = pointer->getChild(0);
-    NodePointer fct_type = pointer->getChild(1)->getChild(0);
-    print(atype_list);
-    print(fct_type);
-    return;
-  }
   case Node::Kind::OwningAddressor:
     printEntity(true, true, ".owningAddressor");
     return;
@@ -3576,6 +3557,7 @@ void NodePrinter::print(NodePointer pointer, bool asContext, bool suppressType)
     Printer << "<ERROR TYPE>";
     return;
 
+  case Node::Kind::DependentPseudogenericSignature:
   case Node::Kind::DependentGenericSignature: {
     Printer << '<';
 

lib/Basic/Remangle.cpp

@@ -305,7 +305,6 @@ namespace {
     void mangleEntityContext(Node *node, EntityContext &ctx);
     void mangleEntityType(Node *node, EntityContext &ctx);
     void mangleEntityGenericType(Node *node, EntityContext &ctx);
-    void mangleGenerics(Node *node, EntityContext &ctx);
 
     bool trySubstitution(Node *node, SubstitutionEntry &entry);
     void addSubstitution(const SubstitutionEntry &entry);
@@ -955,9 +954,6 @@ void Remangler::mangleEntityType(Node *node, EntityContext &ctx) {
 
   // Expand certain kinds of type within the entity context.
   switch (node->getKind()) {
-  case Node::Kind::GenericType:
-    mangleEntityGenericType(node, ctx);
-    return;
   case Node::Kind::FunctionType:
   case Node::Kind::UncurriedFunctionType: {
     Out << (node->getKind() == Node::Kind::FunctionType ? 'F' : 'f');
@@ -1109,9 +1105,12 @@ void Remangler::mangleImplFunctionType(Node *node) {
          i->get()->getKind() == Node::Kind::ImplFunctionAttribute; ++i) {
     mangle(i->get()); // impl function attribute
   }
-  EntityContext ctx(*this);
-  if (i != e && i->get()->getKind() == Node::Kind::Generics) {
-    mangleGenerics((i++)->get(), ctx);
+  if (i != e &&
+      (i->get()->getKind() == Node::Kind::DependentGenericSignature ||
+       i->get()->getKind() == Node::Kind::DependentPseudogenericSignature)) {
+    Out << (i->get()->getKind() == Node::Kind::DependentGenericSignature
+              ? 'G' : 'g');
+    mangleDependentGenericSignature((i++)->get());
   }
   Out << '_';
   for (; i != e && i->get()->getKind() == Node::Kind::ImplParameter; ++i) {
@@ -1294,19 +1293,8 @@ void Remangler::mangleDependentGenericType(Node *node) {
   mangleChildNodes(node); // generic signature, type
 }
 
-void Remangler::mangleGenericType(Node *node) {
-  EntityContext ctx(*this);
-  mangleEntityGenericType(node, ctx);
-}
-
-void Remangler::mangleEntityGenericType(Node *node, EntityContext &ctx) {
-  assert(node->getKind() == Node::Kind::GenericType);
-
-  Out << 'U';
-  assert(node->getNumChildren() == 2);
-
-  mangleGenerics(node->begin()[0].get(), ctx);
-  mangleEntityType(node->begin()[1].get(), ctx);
+void Remangler::mangleDependentPseudogenericSignature(Node *node) {
+  mangleDependentGenericSignature(node);
 }
 
 void Remangler::mangleDependentGenericSignature(Node *node) {
@@ -1378,31 +1366,6 @@ void Remangler::mangleConstrainedType(Node *node) {
   }
 }
 
-void Remangler::mangleGenerics(Node *node) {
-  unreachable("found independent generics node?");
-}
-
-void Remangler::mangleGenerics(Node *node, EntityContext &ctx) {
-  assert(node->getKind() == Node::Kind::Generics);
-
-  unsigned absoluteDepth = ++AbsoluteArchetypeDepth;
-
-  auto i = node->begin(), e = node->end();
-  unsigned index = 0;
-  for (; i != e && i->get()->getKind() == Node::Kind::Archetype; ++i) {
-    auto child = i->get();
-    Archetypes[child->getText()] = ArchetypeInfo{index++, absoluteDepth};
-    mangle(child); // archetype
-  }
-  if (i != e) {
-    Out << 'U';
-    mangleNodes(i, e); // associated types
-    Out << '_';
-  } else {
-    Out << '_';
-  }
-}
-
 void Remangler::mangleArchetype(Node *node) {
   if (node->hasChildren()) {
     assert(node->getNumChildren() == 1);