Revert "[AST] Store Clang type in SILFunctionType for @convention(c) functions."

varungandhi-apple · varungandhi-apple · commit 29cc1b61959e · 2020-01-22T09:04:52.000-08:00
This reverts commit 5f45820.
diff --git a/include/swift/AST/Types.h b/include/swift/AST/Types.h
@@ -44,6 +44,7 @@
 
 namespace clang {
 class Type;
+class FunctionType;
 } // namespace clang
 
 namespace llvm {
@@ -2946,7 +2947,6 @@ class AnyFunctionType : public TypeBase {
       friend ExtInfo;
       friend class AnyFunctionType;
       friend class FunctionType;
-      friend class SILUncommonInfo;
       // We preserve a full clang::Type *, not a clang::FunctionType * as:
       // 1. We need to keep sugar in case we need to present an error to the user.
       // 2. The actual type being stored is [ignoring sugar] either a
@@ -3917,24 +3917,6 @@ namespace Lowering {
   class TypeConverter;
 };
 
-class SILUncommonInfo {
-  friend class SILFunctionType;
-
-  // Invariant: The FunctionType is canonical.
-  // We store a clang::FunctionType * instead of a clang::CanQualType to
-  // avoid depending on the Clang AST in this header.
-  const clang::Type *ClangFunctionType;
-
-  bool empty() const { return !ClangFunctionType; }
-  SILUncommonInfo(const clang::Type *type) : ClangFunctionType(type) {}
-  SILUncommonInfo(AnyFunctionType::ExtInfo::Uncommon uncommon);
-
-public:
-  /// Analog of AnyFunctionType::ExtInfo::Uncommon::printClangFunctionType.
-  void printClangFunctionType(ClangModuleLoader *cml,
-                              llvm::raw_ostream &os) const;
-};
-
 /// SILFunctionType - The lowered type of a function value, suitable
 /// for use by SIL.
 ///
@@ -3943,8 +3925,7 @@ class SILUncommonInfo {
 /// function parameter and result types.
 class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
     private llvm::TrailingObjects<SILFunctionType, SILParameterInfo,
-                                  SILResultInfo, SILYieldInfo, CanType,
-                                  SILUncommonInfo> {
+                                  SILResultInfo, SILYieldInfo, CanType> {
   friend TrailingObjects;
 
   size_t numTrailingObjects(OverloadToken<SILParameterInfo>) const {
@@ -3963,10 +3944,6 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
     return hasResultCache() ? 2 : 0;
   }
 
-  size_t numTrailingObjects(OverloadToken<SILUncommonInfo>) const {
-    return Bits.SILFunctionType.HasUncommonInfo ? 1 : 0;
-  }
-
 public:
   using Language = SILFunctionLanguage;
   using Representation = SILFunctionTypeRepresentation;
@@ -3991,31 +3968,27 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
 
     unsigned Bits; // Naturally sized for speed.
 
-    // For symmetry with AnyFunctionType::Uncommon
-    using Uncommon = SILUncommonInfo;
+    class Uncommon {
+      friend ExtInfo;
+      friend class SILFunctionType;
 
-    Uncommon Other;
+      // Invariant: The FunctionType is canonical.
+      // We store a clang::FunctionType * instead of a clang::CanQualType to
+      // avoid depending on the Clang AST in this header.
+      const clang::FunctionType *ClangFunctionType;
 
-    static void assertIsFunctionType(const clang::Type *);
+      bool empty() const { return !ClangFunctionType; }
+      Uncommon(const clang::FunctionType *type) : ClangFunctionType(type) {}
 
-    ExtInfo(unsigned Bits, Uncommon Other) : Bits(Bits), Other(Other) {
-      auto Rep = Representation(Bits & RepresentationMask);
-      // TODO: [clang-function-type-serialization] Once we start serializing
-      // the Clang type, we should also assert that the pointer is non-null.
-      if ((Rep == Representation::CFunctionPointer) && Other.ClangFunctionType)
-        assertIsFunctionType(Other.ClangFunctionType);
-    }
+    public:
+      /// Analog of AnyFunctionType::ExtInfo::Uncommon::printClangFunctionType.
+      void printClangFunctionType(ClangModuleLoader *cml,
+                                  llvm::raw_ostream &os) const;
+    };
 
-    static constexpr unsigned makeBits(Representation rep,
-                                       bool isPseudogeneric,
-                                       bool isNoEscape,
-                                       DifferentiabilityKind diffKind) {
-      return ((unsigned) rep)
-              | (isPseudogeneric ? PseudogenericMask : 0)
-              | (isNoEscape ? NoEscapeMask : 0)
-              | (((unsigned)diffKind << DifferentiabilityMaskOffset)
-                 & DifferentiabilityMask);
-    }
+    Uncommon Other;
+
+    ExtInfo(unsigned Bits, Uncommon Other) : Bits(Bits), Other(Other) {}
 
     friend class SILFunctionType;
   public:
@@ -4025,21 +3998,15 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
     // Constructor for polymorphic type.
     ExtInfo(Representation rep, bool isPseudogeneric, bool isNoEscape,
             DifferentiabilityKind diffKind,
-            const clang::Type *type)
-      : ExtInfo(makeBits(rep, isPseudogeneric, isNoEscape, diffKind),
+            const clang::FunctionType *type)
+      : ExtInfo(((unsigned) rep)
+                  | (isPseudogeneric ? PseudogenericMask : 0)
+                  | (isNoEscape ? NoEscapeMask : 0)
+                  | (((unsigned)diffKind << DifferentiabilityMaskOffset)
+                     & DifferentiabilityMask),
                 Uncommon(type)) {
     }
 
-    ExtInfo(AnyFunctionType::ExtInfo info, bool isPseudogeneric)
-      : ExtInfo(makeBits(info.getSILRepresentation(),
-                         isPseudogeneric,
-                         info.isNoEscape(),
-                         info.getDifferentiabilityKind()),
-                info.getUncommonInfo().hasValue()
-                ? Uncommon(info.getUncommonInfo().getValue())
-                : Uncommon(nullptr)) {
-    }
-
     static ExtInfo getThin() {
       return ExtInfo(Representation::Thin, false, false,
                      DifferentiabilityKind::NonDifferentiable, nullptr);
@@ -4126,9 +4093,6 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
       return ExtInfo(NoEscape ? (Bits | NoEscapeMask) : (Bits & ~NoEscapeMask),
                      Other);
     }
-    ExtInfo withClangFunctionType(const clang::Type *type) const {
-      return ExtInfo(Bits, Uncommon(type));
-    }
 
     std::pair<unsigned, const void *> getFuncAttrKey() const {
       return std::make_pair(Bits, Other.ClangFunctionType);
@@ -4424,7 +4388,7 @@ class SILFunctionType final : public TypeBase, public llvm::FoldingSetNode,
     return WitnessMethodConformance;
   }
 
-  const clang::Type *getClangFunctionType() const;
+  const clang::FunctionType *getClangFunctionType() const;
 
   ExtInfo getExtInfo() const {
     return ExtInfo(Bits.SILFunctionType.ExtInfoBits, getClangFunctionType());
diff --git a/lib/AST/ASTContext.cpp b/lib/AST/ASTContext.cpp
@@ -3158,13 +3158,7 @@ ArrayRef<Requirement> GenericFunctionType::getRequirements() const {
   return Signature->getRequirements();
 }
 
-SILUncommonInfo::SILUncommonInfo(AnyFunctionType::ExtInfo::Uncommon uncommon) {
-  auto *ty = uncommon.ClangFunctionType;
-  ClangFunctionType = ty ? ty->getCanonicalTypeInternal().getTypePtr()
-                         : nullptr;
-}
-
-void SILUncommonInfo::printClangFunctionType(
+void SILFunctionType::ExtInfo::Uncommon::printClangFunctionType(
     ClangModuleLoader *cml, llvm::raw_ostream &os) const {
   cml->printClangType(ClangFunctionType, os);
 }
@@ -3230,11 +3224,11 @@ SILFunctionType::SILFunctionType(
 
   Bits.SILFunctionType.HasErrorResult = errorResult.hasValue();
   Bits.SILFunctionType.ExtInfoBits = ext.Bits;
+  Bits.SILFunctionType.HasUncommonInfo = false;
   // The use of both assert() and static_assert() below is intentional.
   assert(Bits.SILFunctionType.ExtInfoBits == ext.Bits && "Bits were dropped!");
   static_assert(ExtInfo::NumMaskBits == NumSILExtInfoBits,
                 "ExtInfo and SILFunctionTypeBitfields must agree on bit size");
-  Bits.SILFunctionType.HasUncommonInfo = ext.getUncommonInfo().hasValue();
   Bits.SILFunctionType.CoroutineKind = unsigned(coroutineKind);
   NumParameters = params.size();
   if (coroutineKind == SILCoroutineKind::None) {
@@ -3267,9 +3261,6 @@ SILFunctionType::SILFunctionType(
     getMutableFormalResultsCache() = CanType();
     getMutableAllResultsCache() = CanType();
   }
-  if (auto uncommon = ext.getUncommonInfo())
-    *getTrailingObjects<ExtInfo::Uncommon>() = uncommon.getValue();
-
 #ifndef NDEBUG
   if (ext.getRepresentation() == Representation::WitnessMethod)
     assert(!WitnessMethodConformance.isInvalid() &&
@@ -3369,10 +3360,6 @@ CanSILFunctionType SILFunctionType::get(
   assert(coroutineKind != SILCoroutineKind::None || yields.empty());
   assert(!ext.isPseudogeneric() || genericSig);
 
-  // FIXME: [clang-function-type-serialization] Don't drop the Clang type...
-  if (!ctx.LangOpts.UseClangFunctionTypes)
-    ext = ext.withClangFunctionType(nullptr);
-
   llvm::FoldingSetNodeID id;
   SILFunctionType::Profile(id, genericSig, ext, coroutineKind, callee, params,
                            yields, normalResults, errorResult,
@@ -3389,11 +3376,10 @@ CanSILFunctionType SILFunctionType::get(
 
   // See [SILFunctionType-layout]
   bool hasResultCache = normalResults.size() > 1;
-  size_t bytes = totalSizeToAlloc<SILParameterInfo, SILResultInfo, SILYieldInfo,
-                                  CanType, SILFunctionType::ExtInfo::Uncommon>(
+  size_t bytes =
+    totalSizeToAlloc<SILParameterInfo, SILResultInfo, SILYieldInfo, CanType>(
       params.size(), normalResults.size() + (errorResult ? 1 : 0),
-      yields.size(), hasResultCache ? 2 : 0,
-      ext.getUncommonInfo().hasValue() ? 1 : 0);
+      yields.size(), hasResultCache ? 2 : 0);
 
   void *mem = ctx.Allocate(bytes, alignof(SILFunctionType));
 
diff --git a/lib/AST/ASTDemangler.cpp b/lib/AST/ASTDemangler.cpp
@@ -488,6 +488,12 @@ Type ASTBuilder::createImplFunctionType(
     break;
   }
 
+  // TODO: [store-sil-clang-function-type]
+  auto einfo = SILFunctionType::ExtInfo(
+      representation, flags.isPseudogeneric(), !flags.isEscaping(),
+      DifferentiabilityKind::NonDifferentiable,
+      /*clangFunctionType*/ nullptr);
+
   llvm::SmallVector<SILParameterInfo, 8> funcParams;
   llvm::SmallVector<SILYieldInfo, 8> funcYields;
   llvm::SmallVector<SILResultInfo, 8> funcResults;
@@ -510,26 +516,6 @@ Type ASTBuilder::createImplFunctionType(
     auto conv = getResultConvention(errorResult->getConvention());
     funcErrorResult.emplace(type, conv);
   }
-
-  const clang::Type *clangFnType = nullptr;
-  auto incompleteExtInfo = SILFunctionType::ExtInfo(
-      SILFunctionType::Representation::Thick, flags.isPseudogeneric(),
-      !flags.isEscaping(), DifferentiabilityKind::NonDifferentiable,
-      clangFnType);
-
-  if (representation == SILFunctionType::Representation::CFunctionPointer) {
-    assert(funcResults.size() <= 1 && funcYields.size() == 0
-           && "@convention(c) functions have at most 1 result and 0 yields.");
-    auto result = funcResults.empty() ? Optional<SILResultInfo>()
-                                      : funcResults[0];
-    auto &Context = getASTContext();
-    clangFnType = Context.getCanonicalClangFunctionType(funcParams, result,
-                                                        incompleteExtInfo,
-                                                        representation);
-  }
-  auto einfo = incompleteExtInfo.withRepresentation(representation)
-                                .withClangFunctionType(clangFnType);
-
   return SILFunctionType::get(genericSig, einfo, funcCoroutineKind,
                               funcCalleeConvention, funcParams, funcYields,
                               funcResults, funcErrorResult,
diff --git a/lib/AST/Type.cpp b/lib/AST/Type.cpp
@@ -3229,7 +3229,8 @@ void AnyFunctionType::ExtInfo::Uncommon::printClangFunctionType(
   cml->printClangType(ClangFunctionType, os);
 }
 
-static void assertIsFunctionType(const clang::Type *type) {
+void
+AnyFunctionType::ExtInfo::assertIsFunctionType(const clang::Type *type) {
 #ifndef NDEBUG
   if (!(type->isFunctionPointerType() || type->isBlockPointerType())) {
     SmallString<256> buf;
@@ -3243,10 +3244,6 @@ static void assertIsFunctionType(const clang::Type *type) {
   return;
 }
 
-void AnyFunctionType::ExtInfo::assertIsFunctionType(const clang::Type *type) {
-  ::assertIsFunctionType(type);
-}
-
 const clang::Type *AnyFunctionType::getClangFunctionType() const {
   switch (getKind()) {
   case TypeKind::Function:
@@ -3264,16 +3261,9 @@ const clang::Type *AnyFunctionType::getCanonicalClangFunctionType() const {
   return ty ? ty->getCanonicalTypeInternal().getTypePtr() : nullptr;
 }
 
-void SILFunctionType::ExtInfo::assertIsFunctionType(const clang::Type *type) {
-  ::assertIsFunctionType(type);
-}
-
-const clang::Type *SILFunctionType::getClangFunctionType() const {
-  if (!Bits.SILFunctionType.HasUncommonInfo)
-    return nullptr;
-  auto *type = getTrailingObjects<ExtInfo::Uncommon>()->ClangFunctionType;
-  assert(type && "If the pointer was null, we shouldn't have stored it.");
-  return type;
+// TODO: [store-sil-clang-function-type]
+const clang::FunctionType *SILFunctionType::getClangFunctionType() const {
+  return nullptr;
 }
 
 FunctionType *
diff --git a/lib/ClangImporter/ImportType.cpp b/lib/ClangImporter/ImportType.cpp
@@ -416,11 +416,12 @@ namespace {
       
       if (pointeeQualType->isFunctionType()) {
         auto funcTy = pointeeType->castTo<FunctionType>();
-        auto extInfo = funcTy->getExtInfo().withRepresentation(
-                AnyFunctionType::Representation::CFunctionPointer)
-                                           .withClangFunctionType(type);
         return {
-          FunctionType::get(funcTy->getParams(), funcTy->getResult(), extInfo),
+          FunctionType::get(funcTy->getParams(), funcTy->getResult(),
+            funcTy->getExtInfo()
+              .withRepresentation(
+                AnyFunctionType::Representation::CFunctionPointer)
+              .withClangFunctionType(type)),
           ImportHint::CFunctionPointer
         };
       }
diff --git a/lib/SIL/SILFunctionType.cpp b/lib/SIL/SILFunctionType.cpp
@@ -1266,7 +1266,10 @@ static CanSILFunctionType getSILFunctionType(
 
   // NOTE: SILFunctionType::ExtInfo doesn't track everything that
   // AnyFunctionType::ExtInfo tracks. For example: 'throws' or 'auto-closure'
-  SILFunctionType::ExtInfo silExtInfo(extInfo, pseudogeneric);
+  auto silExtInfo = SILFunctionType::ExtInfo()
+    .withRepresentation(extInfo.getSILRepresentation())
+    .withIsPseudogeneric(pseudogeneric)
+    .withNoEscape(extInfo.isNoEscape());
   
   // Build the substituted generic signature we extracted.
   bool impliedSignature = false;
diff --git a/lib/SILGen/SILGen.cpp b/lib/SILGen/SILGen.cpp
@@ -452,6 +452,8 @@ SILGenModule::getKeyPathProjectionCoroutine(bool isReadAccess,
 
 SILFunction *SILGenModule::emitTopLevelFunction(SILLocation Loc) {
   ASTContext &C = getASTContext();
+  auto extInfo = SILFunctionType::ExtInfo()
+    .withRepresentation(SILFunctionType::Representation::CFunctionPointer);
 
   // Use standard library types if we have them; otherwise, fall back to
   // builtins.
@@ -482,19 +484,13 @@ SILFunction *SILGenModule::emitTopLevelFunction(SILLocation Loc) {
     SILParameterInfo(PtrPtrInt8Ty, ParameterConvention::Direct_Unowned),
   };
 
-  SILResultInfo results[] = {SILResultInfo(Int32Ty, ResultConvention::Unowned)};
-
-  auto rep = SILFunctionType::Representation::CFunctionPointer;
-  auto incompleteExtInfo = SILFunctionType::ExtInfo();
-  auto *clangTy = C.getCanonicalClangFunctionType(params, results[0],
-                                                  incompleteExtInfo, rep);
-  auto extInfo = incompleteExtInfo.withRepresentation(rep)
-                                  .withClangFunctionType(clangTy);
-
   CanSILFunctionType topLevelType = SILFunctionType::get(nullptr, extInfo,
                                    SILCoroutineKind::None,
                                    ParameterConvention::Direct_Unowned,
-                                   params, /*yields*/ {}, results, None,
+                                   params, /*yields*/ {},
+                                   SILResultInfo(Int32Ty,
+                                                 ResultConvention::Unowned),
+                                   None,
                                    SubstitutionMap(), false,
                                    C);
 
diff --git a/lib/SILGen/SILGenBridging.cpp b/lib/SILGen/SILGenBridging.cpp
@@ -541,16 +541,9 @@ ManagedValue SILGenFunction::emitFuncToBlock(SILLocation loc,
             blockInterfaceTy->getParameters().end(),
             std::back_inserter(params));
 
-  auto results = blockInterfaceTy->getResults();
-  auto incompleteExtInfo = SILFunctionType::ExtInfo();
-  auto *clangFnType = getASTContext().getCanonicalClangFunctionType(
-        params, results.empty() ? Optional<SILResultInfo>() : results[0],
-        incompleteExtInfo,
-        SILFunctionType::Representation::CFunctionPointer);
-
-  auto extInfo = incompleteExtInfo
-        .withRepresentation(SILFunctionType::Representation::CFunctionPointer)
-        .withClangFunctionType(clangFnType);
+  auto extInfo =
+      SILFunctionType::ExtInfo()
+        .withRepresentation(SILFunctionType::Representation::CFunctionPointer);
 
   CanGenericSignature genericSig;
   GenericEnvironment *genericEnv = nullptr;
@@ -575,7 +568,8 @@ ManagedValue SILGenFunction::emitFuncToBlock(SILLocation loc,
 
   auto invokeTy = SILFunctionType::get(
       genericSig, extInfo, SILCoroutineKind::None,
-      ParameterConvention::Direct_Unowned, params, /*yields*/ {}, results,
+      ParameterConvention::Direct_Unowned, params, 
+      /*yields*/ {}, blockInterfaceTy->getResults(),
       blockInterfaceTy->getOptionalErrorResult(), SubstitutionMap(), false,
       getASTContext());
 
diff --git a/lib/SILGen/SILGenFunction.cpp b/lib/SILGen/SILGenFunction.cpp
diff --git a/lib/Sema/TypeCheckType.cpp b/lib/Sema/TypeCheckType.cpp
