[SIL] Store ClangTypeInfo in SILFunctionType.

This patch includes a large number of changes to make sure that:
1. When ExtInfo values are created, we store a ClangTypeInfo if applicable.
2. We reduce dependence on storing SIL representations in ASTExtInfo values.
3. Reduce places where we sloppily create ASTExtInfo values which should
   store a Clang type but don't. In certain places, this is unavoidable;
   see [NOTE: ExtInfo-Clang-type-invariant].

Ideally, we would check that the appropriate SILExtInfo does always store
a ClangTypeInfo. However, the presence of the HasClangFunctionTypes option
means that we would need to condition that assertion based on a dynamic check.
Plumbing the setting down to SILExtInfoBuilder's checkInvariants would be too
much work. So we weaken the check for now; we should strengthen it once we
"turn on" HasClangFunctionTypes and remove the dynamic feature switch.

Author: varungandhi-apple

include/swift/AST/ExtInfo.h

@@ -41,6 +41,7 @@ class FunctionType;
 class SILExtInfo;
 class SILExtInfoBuilder;
 class SILFunctionType;
+enum class SILFunctionTypeRepresentation : uint8_t;
 } // namespace swift
 
 namespace swift {
@@ -54,6 +55,7 @@ class ClangTypeInfo {
   friend ASTExtInfoBuilder;
   friend SILExtInfoBuilder;
 
+  // [NOTE: ClangTypeInfo-contents]
   // 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
   //    (for AnyFunctionType).
@@ -81,6 +83,26 @@ class ClangTypeInfo {
   void dump(llvm::raw_ostream &os, const clang::ASTContext &ctx) const;
 };
 
+// MARK: - UnexpectedClangTypeError
+/// Potential errors when trying to store a Clang type in an ExtInfo.
+struct UnexpectedClangTypeError {
+  enum class Kind {
+    NullForCOrBlock,
+    NonnullForNonCOrBlock,
+    NotBlockPointer,
+    NotFunctionPointerOrReference,
+    NonCanonical,
+  };
+  const Kind errorKind;
+  const clang::Type *type;
+
+  static Optional<UnexpectedClangTypeError> checkClangType(
+    SILFunctionTypeRepresentation fnRep, const clang::Type *type,
+    bool expectNonnullForCOrBlock, bool expectCanonical);
+
+  void dump();
+};
+
 // MARK: - FunctionTypeRepresentation
 /// The representation form of a function.
 enum class FunctionTypeRepresentation : uint8_t {
@@ -146,6 +168,41 @@ enum class SILFunctionTypeRepresentation : uint8_t {
   Closure,
 };
 
+constexpr SILFunctionTypeRepresentation
+convertRepresentation(FunctionTypeRepresentation rep) {
+  switch (rep) {
+  case FunctionTypeRepresentation::Swift:
+    return SILFunctionTypeRepresentation::Thick;
+  case FunctionTypeRepresentation::Block:
+    return SILFunctionTypeRepresentation::Block;
+  case FunctionTypeRepresentation::Thin:
+    return SILFunctionTypeRepresentation::Thin;
+  case FunctionTypeRepresentation::CFunctionPointer:
+    return SILFunctionTypeRepresentation::CFunctionPointer;
+  }
+  llvm_unreachable("Unhandled FunctionTypeRepresentation!");
+};
+
+inline Optional<FunctionTypeRepresentation>
+convertRepresentation(SILFunctionTypeRepresentation rep) {
+  switch (rep) {
+  case SILFunctionTypeRepresentation::Thick:
+    return {FunctionTypeRepresentation::Swift};
+  case SILFunctionTypeRepresentation::Block:
+    return {FunctionTypeRepresentation::Block};
+  case SILFunctionTypeRepresentation::Thin:
+    return {FunctionTypeRepresentation::Thin};
+  case SILFunctionTypeRepresentation::CFunctionPointer:
+    return {FunctionTypeRepresentation::CFunctionPointer};
+  case SILFunctionTypeRepresentation::Method:
+  case SILFunctionTypeRepresentation::ObjCMethod:
+  case SILFunctionTypeRepresentation::WitnessMethod:
+  case SILFunctionTypeRepresentation::Closure:
+    return None;
+  }
+  llvm_unreachable("Unhandled SILFunctionTypeRepresentation!");
+};
+
 /// Can this calling convention result in a function being called indirectly
 /// through the runtime.
 constexpr bool canBeCalledIndirectly(SILFunctionTypeRepresentation rep) {
@@ -165,6 +222,25 @@ constexpr bool canBeCalledIndirectly(SILFunctionTypeRepresentation rep) {
   llvm_unreachable("Unhandled SILFunctionTypeRepresentation in switch.");
 }
 
+template <typename Repr> constexpr bool shouldStoreClangType(Repr repr) {
+  static_assert(std::is_same<Repr, FunctionTypeRepresentation>::value ||
+                    std::is_same<Repr, SILFunctionTypeRepresentation>::value,
+                "Expected a Representation type as the argument type.");
+  switch (static_cast<SILFunctionTypeRepresentation>(repr)) {
+  case SILFunctionTypeRepresentation::CFunctionPointer:
+  case SILFunctionTypeRepresentation::Block:
+    return true;
+  case SILFunctionTypeRepresentation::ObjCMethod:
+  case SILFunctionTypeRepresentation::Thick:
+  case SILFunctionTypeRepresentation::Thin:
+  case SILFunctionTypeRepresentation::Method:
+  case SILFunctionTypeRepresentation::WitnessMethod:
+  case SILFunctionTypeRepresentation::Closure:
+    return false;
+  }
+  llvm_unreachable("Unhandled SILFunctionTypeRepresentation.");
+}
+
 // MARK: - ASTExtInfoBuilder
 /// A builder type for creating an \c ASTExtInfo.
 ///
@@ -292,7 +368,8 @@ class ASTExtInfoBuilder {
   LLVM_NODISCARD
   ASTExtInfoBuilder withRepresentation(Representation rep) const {
     return ASTExtInfoBuilder((bits & ~RepresentationMask) | (unsigned)rep,
-                             clangTypeInfo);
+                             shouldStoreClangType(rep) ? clangTypeInfo
+                                                       : ClangTypeInfo());
   }
   LLVM_NODISCARD
   ASTExtInfoBuilder withNoEscape(bool noEscape = true) const {
@@ -333,7 +410,8 @@ class ASTExtInfoBuilder {
   ASTExtInfoBuilder
   withSILRepresentation(SILFunctionTypeRepresentation rep) const {
     return ASTExtInfoBuilder((bits & ~RepresentationMask) | (unsigned)rep,
-                             clangTypeInfo);
+                             shouldStoreClangType(rep) ? clangTypeInfo
+                                                       : ClangTypeInfo());
   }
 
   bool isEqualTo(ASTExtInfoBuilder other, bool useClangTypes) const {
@@ -508,7 +586,7 @@ class SILExtInfoBuilder {
   using Representation = SILFunctionTypeRepresentation;
 
   SILExtInfoBuilder(unsigned bits, ClangTypeInfo clangTypeInfo)
-      : bits(bits), clangTypeInfo(clangTypeInfo) {}
+      : bits(bits), clangTypeInfo(clangTypeInfo.getCanonical()) {}
 
   static constexpr unsigned makeBits(Representation rep, bool isPseudogeneric,
                                      bool isNoEscape, bool isAsync,
@@ -610,7 +688,8 @@ class SILExtInfoBuilder {
   // the following with methods instead of mutating these objects.
   SILExtInfoBuilder withRepresentation(Representation rep) const {
     return SILExtInfoBuilder((bits & ~RepresentationMask) | (unsigned)rep,
-                             clangTypeInfo);
+                             shouldStoreClangType(rep) ? clangTypeInfo
+                                                       : ClangTypeInfo());
   }
   SILExtInfoBuilder withIsPseudogeneric(bool isPseudogeneric = true) const {
     return SILExtInfoBuilder(isPseudogeneric ? (bits | PseudogenericMask)
@@ -633,6 +712,10 @@ class SILExtInfoBuilder {
             ((unsigned)differentiability << DifferentiabilityMaskOffset),
         clangTypeInfo);
   }
+  LLVM_NODISCARD
+  SILExtInfoBuilder withClangFunctionType(const clang::Type *type) const {
+    return SILExtInfoBuilder(bits, ClangTypeInfo(type).getCanonical());
+  }
 
   bool isEqualTo(SILExtInfoBuilder other, bool useClangTypes) const {
     return bits == other.bits &&
@@ -669,6 +752,11 @@ class SILExtInfo {
 public:
   SILExtInfo() : builder() { builder.checkInvariants(); };
 
+  SILExtInfo(ASTExtInfo info, bool isPseudogeneric)
+      : builder(info.intoBuilder(), isPseudogeneric) {
+    builder.checkInvariants();
+  }
+
   static SILExtInfo getThin() {
     return SILExtInfoBuilder(SILExtInfoBuilder::Representation::Thin, false,
                              false, false,
@@ -730,6 +818,8 @@ class SILExtInfo {
   constexpr std::pair<unsigned, const void *> getFuncAttrKey() const {
     return builder.getFuncAttrKey();
   }
+
+  Optional<UnexpectedClangTypeError> checkClangType() const;
 };
 
 /// Helper function to obtain the useClangTypes parameter for checking equality

include/swift/AST/Types.h

@@ -3888,7 +3888,7 @@ class SILFunctionType final
       public llvm::FoldingSetNode,
       private llvm::TrailingObjects<SILFunctionType, SILParameterInfo,
                                     SILResultInfo, SILYieldInfo,
-                                    SubstitutionMap, CanType> {
+                                    SubstitutionMap, CanType, ClangTypeInfo> {
   friend TrailingObjects;
 
   size_t numTrailingObjects(OverloadToken<SILParameterInfo>) const {
@@ -3912,6 +3912,10 @@ class SILFunctionType final
            size_t(hasInvocationSubstitutions());
   }
 
+  size_t numTrailingObjects(OverloadToken<ClangTypeInfo>) const {
+    return Bits.SILFunctionType.HasClangTypeInfo ? 1 : 0;
+  }
+
 public:
   using ExtInfo = SILExtInfo;
   using ExtInfoBuilder = SILExtInfoBuilder;

include/swift/SIL/TypeLowering.h

@@ -55,20 +55,17 @@ CanAnyFunctionType adjustFunctionType(CanAnyFunctionType type,
                                       AnyFunctionType::ExtInfo extInfo);
 
 /// Change the given function type's representation.
-inline CanAnyFunctionType adjustFunctionType(CanAnyFunctionType t,
-                                          SILFunctionType::Representation rep) {
-  auto extInfo =
-      t->getExtInfo().intoBuilder().withSILRepresentation(rep).build();
-  return adjustFunctionType(t, extInfo);  
+inline CanAnyFunctionType
+adjustFunctionType(CanAnyFunctionType t, AnyFunctionType::Representation rep,
+                   ClangTypeInfo clangTypeInfo) {
+  auto extInfo = t->getExtInfo()
+                     .intoBuilder()
+                     .withRepresentation(rep)
+                     .withClangFunctionType(clangTypeInfo.getType())
+                     .build();
+  return adjustFunctionType(t, extInfo);
 }
 
-/// Change the given function type's representation.
-inline CanAnyFunctionType adjustFunctionType(CanAnyFunctionType t,
-                                          AnyFunctionType::Representation rep) {
-  auto extInfo = t->getExtInfo().withRepresentation(rep);
-  return adjustFunctionType(t, extInfo);  
-}
-  
 /// Given a SIL function type, return a type that is identical except
 /// for using the given ExtInfo.
 CanSILFunctionType
@@ -992,7 +989,8 @@ class TypeConverter {
   /// Given a function type, yield its bridged formal type.
   CanAnyFunctionType getBridgedFunctionType(AbstractionPattern fnPattern,
                                             CanAnyFunctionType fnType,
-                                            Bridgeability bridging);
+                                            Bridgeability bridging,
+                                            SILFunctionTypeRepresentation rep);
 
   /// Given a referenced value and the substituted formal type of a
   /// resulting l-value expression, produce the substituted formal
@@ -1121,7 +1119,7 @@ class TypeConverter {
 CanSILFunctionType getNativeSILFunctionType(
     Lowering::TypeConverter &TC, TypeExpansionContext context,
     Lowering::AbstractionPattern origType, CanAnyFunctionType substType,
-    Optional<SILDeclRef> origConstant = None,
+    SILExtInfo silExtInfo, Optional<SILDeclRef> origConstant = None,
     Optional<SILDeclRef> constant = None,
     Optional<SubstitutionMap> reqtSubs = None,
     ProtocolConformanceRef witnessMethodConformance = ProtocolConformanceRef());

lib/AST/ASTContext.cpp

@@ -3246,6 +3246,9 @@ GenericFunctionType *GenericFunctionType::get(GenericSignature sig,
   // point.
   bool isCanonical = isGenericFunctionTypeCanonical(sig, params, result);
 
+  assert(info.getClangTypeInfo().empty() &&
+         "Generic functions do not have Clang types at the moment.");
+
   if (auto funcTy
         = ctx.getImpl().GenericFunctionTypes.FindNodeOrInsertPos(id, insertPos)) {
     return funcTy;
@@ -3365,6 +3368,7 @@ SILFunctionType::SILFunctionType(
          "Bits were dropped!");
   static_assert(SILExtInfoBuilder::NumMaskBits == NumSILExtInfoBits,
                 "ExtInfo and SILFunctionTypeBitfields must agree on bit size");
+  Bits.SILFunctionType.HasClangTypeInfo = !ext.getClangTypeInfo().empty();
   Bits.SILFunctionType.CoroutineKind = unsigned(coroutineKind);
   NumParameters = params.size();
   if (coroutineKind == SILCoroutineKind::None) {
@@ -3402,6 +3406,9 @@ SILFunctionType::SILFunctionType(
     getMutableFormalResultsCache() = CanType();
     getMutableAllResultsCache() = CanType();
   }
+  if (!ext.getClangTypeInfo().empty())
+    *getTrailingObjects<ClangTypeInfo>() = ext.getClangTypeInfo();
+
 #ifndef NDEBUG
   if (ext.getRepresentation() == Representation::WitnessMethod)
     assert(!WitnessMethodConformance.isInvalid() &&
@@ -3524,6 +3531,21 @@ CanSILFunctionType SILFunctionType::get(
 
   patternSubs = patternSubs.getCanonical();
   invocationSubs = invocationSubs.getCanonical();
+
+  // [FIXME: Clang-type-plumbing]
+  if (ctx.LangOpts.UseClangFunctionTypes) {
+    if (auto error = ext.checkClangType()) {
+      error.getValue().dump();
+      llvm_unreachable("Unexpected Clang type in SILExtInfo.");
+    }
+  } else if (!ext.getClangTypeInfo().empty()) {
+    // Unlike AnyFunctionType, SILFunctionType is always canonical. Hence,
+    // conditionalizing canonical type computation based on
+    // UseClangFunctionTypes like AnyFunctionType is not feasible. It is simpler
+    // to drop the Clang type altogether.
+    ext = ext.intoBuilder().withClangFunctionType(nullptr).build();
+  }
+
 
   llvm::FoldingSetNodeID id;
   SILFunctionType::Profile(id, genericSig, ext, coroutineKind, callee, params,
@@ -3541,12 +3563,11 @@ CanSILFunctionType SILFunctionType::get(
 
   // See [NOTE: SILFunctionType-layout]
   bool hasResultCache = normalResults.size() > 1;
-  size_t bytes =
-    totalSizeToAlloc<SILParameterInfo, SILResultInfo, SILYieldInfo,
-                     SubstitutionMap, CanType>(
+  size_t bytes = totalSizeToAlloc<SILParameterInfo, SILResultInfo, SILYieldInfo,
+                                  SubstitutionMap, CanType, ClangTypeInfo>(
       params.size(), normalResults.size() + (errorResult ? 1 : 0),
       yields.size(), (patternSubs ? 1 : 0) + (invocationSubs ? 1 : 0),
-      hasResultCache ? 2 : 0);
+      hasResultCache ? 2 : 0, ext.getClangTypeInfo().empty() ? 0 : 1);
 
   void *mem = ctx.Allocate(bytes, alignof(SILFunctionType));
 

lib/AST/ASTDemangler.cpp

@@ -396,7 +396,7 @@ Type ASTBuilder::createFunctionType(
     && !flags.isEscaping();
 
   const clang::Type *clangFunctionType = nullptr;
-  if (representation == FunctionTypeRepresentation::CFunctionPointer)
+  if (shouldStoreClangType(representation))
     clangFunctionType = Ctx.getClangFunctionType(funcParams, output,
                                                  representation);
 
@@ -523,12 +523,6 @@ Type ASTBuilder::createImplFunctionType(
     break;
   }
 
-  // [TODO: Store-SIL-Clang-type]
-  auto einfo = SILExtInfoBuilder(representation, flags.isPseudogeneric(),
-                                 !flags.isEscaping(), flags.isAsync(), diffKind,
-                                 /*clangFunctionType*/ nullptr)
-                   .build();
-
   llvm::SmallVector<SILParameterInfo, 8> funcParams;
   llvm::SmallVector<SILYieldInfo, 8> funcYields;
   llvm::SmallVector<SILResultInfo, 8> funcResults;
@@ -553,6 +547,21 @@ Type ASTBuilder::createImplFunctionType(
     auto conv = getResultConvention(errorResult->getConvention());
     funcErrorResult.emplace(type, conv);
   }
+
+  const clang::Type *clangFnType = nullptr;
+  if (shouldStoreClangType(representation)) {
+    assert(funcResults.size() <= 1 && funcYields.size() == 0 &&
+           "C functions and blocks have at most 1 result and 0 yields.");
+    auto result =
+        funcResults.empty() ? Optional<SILResultInfo>() : funcResults[0];
+    clangFnType = getASTContext().getCanonicalClangFunctionType(
+        funcParams, result, representation);
+  }
+  auto einfo = SILFunctionType::ExtInfoBuilder(
+                   representation, flags.isPseudogeneric(), !flags.isEscaping(),
+                   flags.isAsync(), diffKind, clangFnType)
+                   .build();
+
   return SILFunctionType::get(genericSig, einfo, funcCoroutineKind,
                               funcCalleeConvention, funcParams, funcYields,
                               funcResults, funcErrorResult,

lib/AST/ASTDumper.cpp

@@ -3831,6 +3831,14 @@ namespace {
       OS << '\n';
       T->getInvocationSubstitutions().dump(OS, SubstitutionMap::DumpStyle::Full,
                                            Indent+2);
+      if (!T->getClangTypeInfo().empty()) {
+        std::string s;
+        llvm::raw_string_ostream os(s);
+        auto &ctx =
+            T->getASTContext().getClangModuleLoader()->getClangASTContext();
+        T->getClangTypeInfo().dump(os, ctx);
+        printField("clang_type", os.str());
+      }
       PrintWithColorRAII(OS, ParenthesisColor) << ')';
     }