Revert "[AST] De/mangling for functions with generic sigs."

nate-chandler · nate-chandler · commit 19d9ebd761c5 · 2021-04-06T15:41:43.000-07:00
This reverts commit dbe689a.
diff --git a/include/swift/AST/ASTDemangler.h b/include/swift/AST/ASTDemangler.h
@@ -59,8 +59,6 @@ class ASTBuilder {
   using BuiltType = swift::Type;
   using BuiltTypeDecl = swift::GenericTypeDecl *; // nominal or type alias
   using BuiltProtocolDecl = swift::ProtocolDecl *;
-  using BuiltSubstitution = std::pair<Type, Type>;
-  using BuiltRequirement = swift::Requirement;
   explicit ASTBuilder(ASTContext &ctx) : Ctx(ctx) {}
 
   ASTContext &getASTContext() { return Ctx; }
@@ -103,14 +101,11 @@ class ASTBuilder {
       FunctionMetadataDifferentiabilityKind diffKind);
 
   Type createImplFunctionType(
-      Demangle::ImplParameterConvention calleeConvention,
-      BuiltRequirement *witnessMethodConformanceRequirement,
-      ArrayRef<BuiltType> GenericParameters,
-      ArrayRef<BuiltRequirement> Requirements,
-      ArrayRef<Demangle::ImplFunctionParam<Type>> params,
-      ArrayRef<Demangle::ImplFunctionResult<Type>> results,
-      Optional<Demangle::ImplFunctionResult<Type>> errorResult,
-      ImplFunctionTypeFlags flags);
+    Demangle::ImplParameterConvention calleeConvention,
+    ArrayRef<Demangle::ImplFunctionParam<Type>> params,
+    ArrayRef<Demangle::ImplFunctionResult<Type>> results,
+    Optional<Demangle::ImplFunctionResult<Type>> errorResult,
+    ImplFunctionTypeFlags flags);
 
   Type createProtocolCompositionType(ArrayRef<ProtocolDecl *> protocols,
                                      Type superclass,
@@ -135,6 +130,8 @@ class ASTBuilder {
 
   Type createSILBoxType(Type base);
   using BuiltSILBoxField = llvm::PointerIntPair<Type, 1>;
+  using BuiltSubstitution = std::pair<Type, Type>;
+  using BuiltRequirement = swift::Requirement;
   using BuiltLayoutConstraint = swift::LayoutConstraint;
   Type createSILBoxTypeWithLayout(ArrayRef<BuiltSILBoxField> Fields,
                                   ArrayRef<BuiltSubstitution> Substitutions,
diff --git a/include/swift/Demangling/TypeDecoder.h b/include/swift/Demangling/TypeDecoder.h
@@ -814,12 +814,9 @@ class TypeDecoder {
     }
     case NodeKind::ImplFunctionType: {
       auto calleeConvention = ImplParameterConvention::Direct_Unowned;
-      BuiltRequirement *witnessMethodConformanceRequirement = nullptr;
       llvm::SmallVector<ImplFunctionParam<BuiltType>, 8> parameters;
       llvm::SmallVector<ImplFunctionResult<BuiltType>, 8> results;
       llvm::SmallVector<ImplFunctionResult<BuiltType>, 8> errorResults;
-      llvm::SmallVector<BuiltType, 4> genericParameters;
-      llvm::SmallVector<BuiltRequirement, 4> requirements;
       ImplFunctionTypeFlags flags;
 
       for (unsigned i = 0; i < Node->getNumChildren(); i++) {
@@ -852,9 +849,6 @@ class TypeDecoder {
           } else if (text == "block") {
             flags =
               flags.withRepresentation(ImplFunctionRepresentation::Block);
-          } else if (text == "witness_method") {
-            flags = flags.withRepresentation(
-                ImplFunctionRepresentation::WitnessMethod);
           }
         } else if (child->getKind() == NodeKind::ImplFunctionAttribute) {
           if (!child->hasText())
@@ -892,27 +886,6 @@ class TypeDecoder {
           if (decodeImplFunctionPart(child, errorResults))
             return MAKE_NODE_TYPE_ERROR0(child,
                                          "failed to decode function part");
-        } else if (child->getKind() == NodeKind::DependentGenericSignature) {
-          llvm::SmallVector<unsigned, 4> genericParamsAtDepth;
-
-          if (auto error = decodeDependentGenericSignatureNode(
-                  child, requirements, genericParamsAtDepth))
-            return *error;
-          if (flags.getRepresentation() ==
-              ImplFunctionRepresentation::WitnessMethod) {
-            // By convention, the first requirement of a witness method is the
-            // conformance of Self to the protocol.
-            witnessMethodConformanceRequirement = &requirements[0];
-          }
-
-          for (unsigned long depth = 0, depths = genericParamsAtDepth.size();
-               depth < depths; ++depth) {
-            for (unsigned index = 0; index < genericParamsAtDepth[depth];
-                 ++index) {
-              genericParameters.emplace_back(
-                  Builder.createGenericTypeParameterType(depth, index));
-            }
-          }
         } else {
           return MAKE_NODE_TYPE_ERROR0(child, "unexpected kind");
         }
@@ -933,11 +906,11 @@ class TypeDecoder {
       // TODO: Some cases not handled above, but *probably* they cannot
       // appear as the types of values in SIL (yet?):
       // - functions with yield returns
+      // - functions with generic signatures
       // - foreign error conventions
-      return Builder.createImplFunctionType(
-          calleeConvention, witnessMethodConformanceRequirement,
-          genericParameters, requirements, parameters, results, errorResult,
-          flags);
+      return Builder.createImplFunctionType(calleeConvention,
+                                            parameters, results,
+                                            errorResult, flags);
     }
 
     case NodeKind::ArgumentTuple:
@@ -1108,12 +1081,35 @@ class TypeDecoder {
           return MAKE_NODE_TYPE_ERROR0(substNode, "expected type list");
 
         auto *dependentGenericSignatureNode = Node->getChild(1);
+        if (dependentGenericSignatureNode->getKind() !=
+            NodeKind::DependentGenericSignature)
+          return MAKE_NODE_TYPE_ERROR0(dependentGenericSignatureNode,
+                                       "expected dependent generic signature");
+        if (dependentGenericSignatureNode->getNumChildren() < 1)
+          return MAKE_NODE_TYPE_ERROR(
+              dependentGenericSignatureNode,
+              "fewer children (%zu) than required (1)",
+              dependentGenericSignatureNode->getNumChildren());
+        decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,
+                          BuilderType>(
+            dependentGenericSignatureNode, requirements, Builder/*,
+            [&](NodePointer Node) -> BuiltType {
+              return decodeMangledType(Node).getType();
+            },
+            [&](LayoutConstraintKind Kind) -> BuiltLayoutConstraint {
+              return {}; // Not implemented!
+            },
+            [&](LayoutConstraintKind Kind, unsigned SizeInBits,
+                unsigned Alignment) -> BuiltLayoutConstraint {
+              return {}; // Not Implemented!
+              }*/);
+        // The number of generic parameters at each depth are in a mini
+        // state machine and come first.
         llvm::SmallVector<unsigned, 4> genericParamsAtDepth;
-        if (auto error = decodeDependentGenericSignatureNode(
-                dependentGenericSignatureNode, requirements,
-                genericParamsAtDepth))
-          return *error;
-
+        for (auto *reqNode : *dependentGenericSignatureNode)
+          if (reqNode->getKind() == NodeKind::DependentGenericParamCount)
+            if (reqNode->hasIndex())
+              genericParamsAtDepth.push_back(reqNode->getIndex());
         unsigned depth = 0;
         unsigned index = 0;
         for (auto *subst : *substNode) {
@@ -1463,43 +1459,6 @@ class TypeDecoder {
     params.push_back(std::move(param));
     return true;
   }
-
-  llvm::Optional<TypeLookupError> decodeDependentGenericSignatureNode(
-      NodePointer dependentGenericSignatureNode,
-      llvm::SmallVectorImpl<BuiltRequirement> &requirements,
-      llvm::SmallVectorImpl<unsigned> &genericParamsAtDepth) {
-    using NodeKind = Demangle::Node::Kind;
-    if (dependentGenericSignatureNode->getKind() !=
-        NodeKind::DependentGenericSignature)
-      return llvm::Optional<TypeLookupError>(
-          MAKE_NODE_TYPE_ERROR0(dependentGenericSignatureNode,
-                                "expected dependent generic signature"));
-    if (dependentGenericSignatureNode->getNumChildren() < 1)
-      return llvm::Optional<TypeLookupError>(MAKE_NODE_TYPE_ERROR(
-          dependentGenericSignatureNode,
-          "fewer children (%zu) than required (1)",
-          dependentGenericSignatureNode->getNumChildren()));
-    decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,
-                      BuilderType>(dependentGenericSignatureNode, requirements,
-                                   Builder /*,
-[&](NodePointer Node) -> BuiltType {
-return decodeMangledType(Node).getType();
-},
-[&](LayoutConstraintKind Kind) -> BuiltLayoutConstraint {
-return {}; // Not implemented!
-},
-[&](LayoutConstraintKind Kind, unsigned SizeInBits,
-unsigned Alignment) -> BuiltLayoutConstraint {
-return {}; // Not Implemented!
-}*/);
-    // The number of generic parameters at each depth are in a mini
-    // state machine and come first.
-    for (auto *reqNode : *dependentGenericSignatureNode)
-      if (reqNode->getKind() == NodeKind::DependentGenericParamCount)
-        if (reqNode->hasIndex())
-          genericParamsAtDepth.push_back(reqNode->getIndex());
-    return llvm::None;
-  }
 };
 
 template <typename BuilderType>
diff --git a/include/swift/Reflection/TypeRefBuilder.h b/include/swift/Reflection/TypeRefBuilder.h
@@ -418,14 +418,9 @@ class TypeRefBuilder {
       FunctionMetadataDifferentiabilityKind diffKind) {
     return FunctionTypeRef::create(*this, params, result, flags, diffKind);
   }
-  using BuiltSubstitution = std::pair<const TypeRef *, const TypeRef *>;
-  using BuiltRequirement = TypeRefRequirement;
 
   const FunctionTypeRef *createImplFunctionType(
       Demangle::ImplParameterConvention calleeConvention,
-      BuiltRequirement *witnessMethodConformanceRequirement,
-      const llvm::SmallVectorImpl<BuiltType> &genericParameters,
-      const llvm::SmallVectorImpl<BuiltRequirement> &requirements,
       llvm::ArrayRef<Demangle::ImplFunctionParam<const TypeRef *>> params,
       llvm::ArrayRef<Demangle::ImplFunctionResult<const TypeRef *>> results,
       llvm::Optional<Demangle::ImplFunctionResult<const TypeRef *>> errorResult,
@@ -545,6 +540,8 @@ class TypeRefBuilder {
   }
 
   using BuiltSILBoxField = typename SILBoxTypeWithLayoutTypeRef::Field;
+  using BuiltSubstitution = std::pair<const TypeRef *, const TypeRef *>;
+  using BuiltRequirement = TypeRefRequirement;
   using BuiltLayoutConstraint = TypeRefLayoutConstraint;
   BuiltLayoutConstraint getLayoutConstraint(LayoutConstraintKind kind) {
     // FIXME: Implement this.
diff --git a/lib/AST/ASTDemangler.cpp b/lib/AST/ASTDemangler.cpp
@@ -483,24 +483,11 @@ getResultDifferentiability(ImplResultDifferentiability diffKind) {
 
 Type ASTBuilder::createImplFunctionType(
     Demangle::ImplParameterConvention calleeConvention,
-    BuiltRequirement *witnessMethodConformanceRequirement,
-    ArrayRef<BuiltType> GenericParameters,
-    ArrayRef<BuiltRequirement> Requirements,
     ArrayRef<Demangle::ImplFunctionParam<Type>> params,
     ArrayRef<Demangle::ImplFunctionResult<Type>> results,
     Optional<Demangle::ImplFunctionResult<Type>> errorResult,
     ImplFunctionTypeFlags flags) {
   GenericSignature genericSig;
-  if (GenericParameters.size() > 0) {
-    llvm::SmallVector<GenericTypeParamType *, 4> CastGenericParameters;
-    for (auto Parameter : GenericParameters) {
-      CastGenericParameters.push_back(
-          Parameter->castTo<GenericTypeParamType>());
-    }
-    genericSig = GenericSignature::get(CastGenericParameters, Requirements);
-  } else {
-    assert(Requirements.size() == 0);
-  }
 
   SILCoroutineKind funcCoroutineKind = SILCoroutineKind::None;
   ParameterConvention funcCalleeConvention =
@@ -585,15 +572,11 @@ Type ASTBuilder::createImplFunctionType(
                    representation, flags.isPseudogeneric(), !flags.isEscaping(),
                    flags.isSendable(), flags.isAsync(), diffKind, clangFnType)
                    .build();
-  auto witnessMethodConformance =
-      witnessMethodConformanceRequirement
-          ? ProtocolConformanceRef(
-                witnessMethodConformanceRequirement->getProtocolDecl())
-          : ProtocolConformanceRef();
-  return SILFunctionType::get(
-      genericSig, einfo, funcCoroutineKind, funcCalleeConvention, funcParams,
-      funcYields, funcResults, funcErrorResult,
-      SubstitutionMap(), SubstitutionMap(), Ctx, witnessMethodConformance);
+
+  return SILFunctionType::get(genericSig, einfo, funcCoroutineKind,
+                              funcCalleeConvention, funcParams, funcYields,
+                              funcResults, funcErrorResult,
+                              SubstitutionMap(), SubstitutionMap(), Ctx);
 }
 
 Type ASTBuilder::createProtocolCompositionType(
diff --git a/stdlib/public/runtime/MetadataLookup.cpp b/stdlib/public/runtime/MetadataLookup.cpp
@@ -1508,58 +1508,8 @@ class DecodedMetadataBuilder {
               result);
   }
 
-  struct BuiltLayoutConstraint {
-    bool operator==(BuiltLayoutConstraint rhs) const { return true; }
-    operator bool() const { return true; }
-  };
-  using BuiltLayoutConstraint = BuiltLayoutConstraint;
-  BuiltLayoutConstraint getLayoutConstraint(LayoutConstraintKind kind) {
-    return {};
-  }
-  BuiltLayoutConstraint
-  getLayoutConstraintWithSizeAlign(LayoutConstraintKind kind, unsigned size,
-                                   unsigned alignment) {
-    return {};
-  }
-
-#if LLVM_PTR_SIZE == 4
-  /// Unfortunately the alignment of TypeRef is too large to squeeze in 3 extra
-  /// bits on (some?) 32-bit systems.
-  class BigBuiltTypeIntPair {
-    BuiltType Ptr;
-    RequirementKind Int;
-
-  public:
-    BigBuiltTypeIntPair(BuiltType ptr, RequirementKind i) : Ptr(ptr), Int(i) {}
-    RequirementKind getInt() const { return Int; }
-    BuiltType getPointer() const { return Ptr; }
-    uint64_t getOpaqueValue() const {
-      return (uint64_t)Ptr | ((uint64_t)Int << 32);
-    }
-  };
-#endif
-
-  struct Requirement : public RequirementBase<BuiltType,
-#if LLVM_PTR_SIZE == 4
-         BigBuiltTypeIntPair,
-#else
-         llvm::PointerIntPair<BuiltType, 3, RequirementKind>,
-
-#endif
-         BuiltLayoutConstraint> {
-    Requirement(RequirementKind kind, BuiltType first, BuiltType second)
-        : RequirementBase(kind, first, second) {}
-    Requirement(RequirementKind kind, BuiltType first,
-                BuiltLayoutConstraint second)
-        : RequirementBase(kind, first, second) {}
-  };
-  using BuiltRequirement = Requirement;
-
   TypeLookupErrorOr<BuiltType> createImplFunctionType(
       Demangle::ImplParameterConvention calleeConvention,
-      BuiltRequirement *witnessMethodConformanceRequirement,
-      llvm::ArrayRef<BuiltType> genericParameters,
-      llvm::ArrayRef<BuiltRequirement> requirements,
       llvm::ArrayRef<Demangle::ImplFunctionParam<BuiltType>> params,
       llvm::ArrayRef<Demangle::ImplFunctionResult<BuiltType>> results,
       llvm::Optional<Demangle::ImplFunctionResult<BuiltType>> errorResult,
@@ -1627,6 +1577,51 @@ class DecodedMetadataBuilder {
 
   using BuiltSILBoxField = llvm::PointerIntPair<BuiltType, 1>;
   using BuiltSubstitution = std::pair<BuiltType, BuiltType>;
+  struct BuiltLayoutConstraint {
+    bool operator==(BuiltLayoutConstraint rhs) const { return true; }
+    operator bool() const { return true; }
+  };
+  using BuiltLayoutConstraint = BuiltLayoutConstraint;
+  BuiltLayoutConstraint getLayoutConstraint(LayoutConstraintKind kind) {
+    return {};
+  }
+  BuiltLayoutConstraint
+  getLayoutConstraintWithSizeAlign(LayoutConstraintKind kind, unsigned size,
+                                   unsigned alignment) {
+    return {};
+  }
+
+#if LLVM_PTR_SIZE == 4
+  /// Unfortunately the alignment of TypeRef is too large to squeeze in 3 extra
+  /// bits on (some?) 32-bit systems.
+  class BigBuiltTypeIntPair {
+    BuiltType Ptr;
+    RequirementKind Int;
+  public:
+    BigBuiltTypeIntPair(BuiltType ptr, RequirementKind i) : Ptr(ptr), Int(i) {}
+    RequirementKind getInt() const { return Int; }
+    BuiltType getPointer() const { return Ptr; }
+    uint64_t getOpaqueValue() const {
+      return (uint64_t)Ptr | ((uint64_t)Int << 32);
+    }
+  };
+#endif
+
+  struct Requirement : public RequirementBase<BuiltType,
+#if LLVM_PTR_SIZE == 4
+         BigBuiltTypeIntPair,
+#else
+         llvm::PointerIntPair<BuiltType, 3, RequirementKind>,
+
+#endif
+         BuiltLayoutConstraint> {
+    Requirement(RequirementKind kind, BuiltType first, BuiltType second)
+        : RequirementBase(kind, first, second) {}
+    Requirement(RequirementKind kind, BuiltType first,
+                BuiltLayoutConstraint second)
+        : RequirementBase(kind, first, second) {}
+  };
+  using BuiltRequirement = Requirement;
 
   TypeLookupErrorOr<BuiltType> createSILBoxTypeWithLayout(
       llvm::ArrayRef<BuiltSILBoxField> Fields,
