[AST] Add ClangTypeConverter, computing C types for FunctionTypes.

Note: The change in ASTBuilder::createFunctionType is functionally minor,
but we need the FunctionType::Params computed _before_ the ExtInfo, so we
need to shuffle a bunch of code around.

Author: varungandhi-apple

include/swift/AST/ASTContext.h

@@ -22,6 +22,7 @@
 #include "swift/AST/Identifier.h"
 #include "swift/AST/SearchPathOptions.h"
 #include "swift/AST/Type.h"
+#include "swift/AST/Types.h"
 #include "swift/AST/TypeAlignments.h"
 #include "swift/Basic/LangOptions.h"
 #include "swift/Basic/Malloc.h"
@@ -557,6 +558,19 @@ class ASTContext final {
   Type getBridgedToObjC(const DeclContext *dc, Type type,
                         Type *bridgedValueType = nullptr) const;
 
+  /// Get the Clang type corresponding to a Swift function type.
+  ///
+  /// \param params The function parameters.
+  /// \param resultTy The Swift result type.
+  /// \param incompleteExtInfo Used to convey escaping and throwing
+  ///                          information, in case it is needed.
+  /// \param trueRep The actual calling convention, which must be C-compatible.
+  ///                The calling convention in \p incompleteExtInfo is ignored.
+  const clang::Type *
+  getClangFunctionType(ArrayRef<AnyFunctionType::Param> params, Type resultTy,
+                       const FunctionType::ExtInfo incompleteExtInfo,
+                       FunctionTypeRepresentation trueRep);
+
   /// Determine whether the given Swift type is representable in a
   /// given foreign language.
   ForeignRepresentationInfo

include/swift/AST/ClangModuleLoader.h

@@ -20,6 +20,7 @@ class ASTContext;
 class CompilerInstance;
 class Preprocessor;
 class Sema;
+class TargetInfo;
 } // namespace clang
 
 namespace swift {
@@ -46,6 +47,7 @@ class ClangModuleLoader : public ModuleLoader {
   using ModuleLoader::ModuleLoader;
 
 public:
+  virtual clang::TargetInfo &getTargetInfo() const = 0;
   virtual clang::ASTContext &getClangASTContext() const = 0;
   virtual clang::Preprocessor &getClangPreprocessor() const = 0;
   virtual clang::Sema &getClangSema() const = 0;

include/swift/AST/Types.h

@@ -2975,6 +2975,11 @@ class AnyFunctionType : public TypeBase {
       return Representation(rawRep);
     }
 
+    /// Return the underlying Uncommon value if it is not the default value.
+    Optional<Uncommon> getUncommonInfo() const {
+      return Other.empty() ? Optional<Uncommon>() : Other;
+    }
+
     bool hasSelfParam() const {
       switch (getSILRepresentation()) {
       case SILFunctionTypeRepresentation::Thick:
@@ -3060,12 +3065,16 @@ class AnyFunctionType : public TypeBase {
   };
 
 protected:
+  /// Create an AnyFunctionType.
+  ///
+  /// Subclasses are responsible for storing and retrieving the
+  /// ExtInfo::Uncommon value if one is present.
   AnyFunctionType(TypeKind Kind, const ASTContext *CanTypeContext,
                   Type Output, RecursiveTypeProperties properties,
                   unsigned NumParams, ExtInfo Info)
   : TypeBase(Kind, CanTypeContext, properties), Output(Output) {
     Bits.AnyFunctionType.ExtInfoBits = Info.Bits;
-    Bits.AnyFunctionType.HasUncommonInfo = false;
+    Bits.AnyFunctionType.HasUncommonInfo = Info.getUncommonInfo().hasValue();
     Bits.AnyFunctionType.NumParams = NumParams;
     assert(Bits.AnyFunctionType.NumParams == NumParams && "Params dropped!");
     // The use of both assert() and static_assert() is intentional.
@@ -3119,9 +3128,14 @@ class AnyFunctionType : public TypeBase {
     return ExtInfo(Bits.AnyFunctionType.ExtInfoBits, getClangFunctionType());
   }
 
-  ExtInfo getCanonicalExtInfo() const {
+  /// Get the canonical ExtInfo for the function type.
+  ///
+  /// The parameter useClangFunctionType is present only for staging purposes.
+  /// In the future, we will always use the canonical clang function type.
+  ExtInfo getCanonicalExtInfo(bool useClangFunctionType) const {
     return ExtInfo(Bits.AnyFunctionType.ExtInfoBits,
-                   getCanonicalClangFunctionType());
+                   useClangFunctionType ? getCanonicalClangFunctionType()
+                                        : nullptr);
   }
 
   /// Get the representation of the function type.
@@ -3187,16 +3201,25 @@ END_CAN_TYPE_WRAPPER(AnyFunctionType, Type)
 inline AnyFunctionType::CanYield AnyFunctionType::Yield::getCanonical() const {
   return CanYield(getType()->getCanonicalType(), getFlags());
 }
-
 /// FunctionType - A monomorphic function type, specified with an arrow.
 ///
 /// For example:
 ///   let x : (Float, Int) -> Int
 class FunctionType final : public AnyFunctionType,
     public llvm::FoldingSetNode,
-    private llvm::TrailingObjects<FunctionType, AnyFunctionType::Param> {
+    private llvm::TrailingObjects<FunctionType, AnyFunctionType::Param,
+                                  AnyFunctionType::ExtInfo::Uncommon> {
   friend TrailingObjects;
 
+
+  size_t numTrailingObjects(OverloadToken<AnyFunctionType::Param>) const {
+    return getNumParams();
+  }
+
+  size_t numTrailingObjects(OverloadToken<ExtInfo::Uncommon>) const {
+    return hasClangFunctionType() ? 1 : 0;
+  }
+
 public:
   /// 'Constructor' Factory Function
   static FunctionType *get(ArrayRef<Param> params, Type result,
@@ -3207,6 +3230,14 @@ class FunctionType final : public AnyFunctionType,
     return {getTrailingObjects<Param>(), getNumParams()};
   }
 
+  const clang::Type *getClangFunctionType() const {
+    if (!hasClangFunctionType())
+      return nullptr;
+    auto *type = getTrailingObjects<ExtInfo::Uncommon>()->ClangFunctionType;
+    assert(type && "If the pointer was null, we shouldn't have stored it.");
+    return type;
+  }
+
   void Profile(llvm::FoldingSetNodeID &ID) {
     Profile(ID, getParams(), getResult(), getExtInfo());
   }

include/swift/Basic/LangOptions.h

@@ -219,6 +219,13 @@ namespace swift {
     /// Build the ASTScope tree lazily
     bool LazyASTScopes = true;
 
+    /// Use Clang function types for computing canonical types.
+    /// If this option is false, the clang function types will still be computed
+    /// but will not be used for checking type equality.
+    /// FIXME: [clang-function-type-serialization] This option should be turned
+    /// on once we start serializing clang function types.
+    bool UseClangFunctionTypes = false;
+
     /// Whether to use the import as member inference system
     ///
     /// When importing a global, try to infer whether we can import it as a

include/swift/ClangImporter/ClangImporter.h

@@ -362,7 +362,7 @@ class ClangImporter final : public ClangModuleLoader {
 
   void verifyAllModules() override;
 
-  clang::TargetInfo &getTargetInfo() const;
+  clang::TargetInfo &getTargetInfo() const override;
   clang::ASTContext &getClangASTContext() const override;
   clang::Preprocessor &getClangPreprocessor() const override;
   clang::Sema &getClangSema() const override;

include/swift/Option/FrontendOptions.td

@@ -151,6 +151,9 @@ def warn_if_astscope_lookup : Flag<["-"], "warn-if-astscope-lookup">,
 def lazy_astscopes : Flag<["-"], "lazy-astscopes">,
   HelpText<"Build ASTScopes lazily">;
 
+def use_clang_function_types : Flag<["-"], "use-clang-function-types">,
+  HelpText<"Use stored Clang function types for computing canonical types.">;
+
 def print_clang_stats : Flag<["-"], "print-clang-stats">,
   HelpText<"Print Clang importer statistics">;
 

lib/AST/ASTContext.cpp

@@ -15,6 +15,7 @@
 //===----------------------------------------------------------------------===//
 
 #include "swift/AST/ASTContext.h"
+#include "ClangTypeConverter.h"
 #include "ForeignRepresentationInfo.h"
 #include "SubstitutionMapStorage.h"
 #include "swift/AST/ClangModuleLoader.h"
@@ -463,6 +464,8 @@ struct ASTContext::Implementation {
   RC<syntax::SyntaxArena> TheSyntaxArena;
 
   llvm::DenseMap<OverrideSignatureKey, GenericSignature> overrideSigCache;
+
+  Optional<ClangTypeConverter> Converter;
 };
 
 ASTContext::Implementation::Implementation()
@@ -2997,11 +3000,17 @@ FunctionType *FunctionType::get(ArrayRef<AnyFunctionType::Param> params,
     return funcTy;
   }
 
-  void *mem = ctx.Allocate(sizeof(FunctionType) +
-                             sizeof(AnyFunctionType::Param) * params.size(),
-                           alignof(FunctionType), arena);
+  Optional<ExtInfo::Uncommon> uncommon = info.getUncommonInfo();
+
+  size_t allocSize =
+    totalSizeToAlloc<AnyFunctionType::Param, ExtInfo::Uncommon>(
+      params.size(), uncommon.hasValue() ? 1 : 0);
+  void *mem = ctx.Allocate(allocSize, alignof(FunctionType), arena);
 
   bool isCanonical = isFunctionTypeCanonical(params, result);
+  if (uncommon.hasValue())
+    isCanonical &= uncommon->ClangFunctionType->isCanonicalUnqualified();
+
   auto funcTy = new (mem) FunctionType(params, result, info,
                                        isCanonical ? &ctx : nullptr,
                                        properties);
@@ -3018,6 +3027,9 @@ FunctionType::FunctionType(ArrayRef<AnyFunctionType::Param> params,
                       output, properties, params.size(), info) {
   std::uninitialized_copy(params.begin(), params.end(),
                           getTrailingObjects<AnyFunctionType::Param>());
+  Optional<ExtInfo::Uncommon> uncommon = info.getUncommonInfo();
+  if (uncommon.hasValue())
+    *getTrailingObjects<ExtInfo::Uncommon>() = uncommon.getValue();
 }
 
 void GenericFunctionType::Profile(llvm::FoldingSetNodeID &ID,
@@ -4323,6 +4335,19 @@ Type ASTContext::getBridgedToObjC(const DeclContext *dc, Type type,
   return Type();
 }
 
+const clang::Type *
+ASTContext::getClangFunctionType(ArrayRef<AnyFunctionType::Param> params,
+                                 Type resultTy,
+                                 FunctionType::ExtInfo incompleteExtInfo,
+                                 FunctionTypeRepresentation trueRep) {
+  auto &impl = getImpl();
+  if (!impl.Converter) {
+    auto *cml = getClangModuleLoader();
+    impl.Converter.emplace(*this, cml->getClangASTContext(), LangOpts.Target);
+  }
+  return impl.Converter.getValue().getFunctionType(params, resultTy, trueRep);
+}
+
 CanGenericSignature ASTContext::getSingleGenericParameterSignature() const {
   if (auto theSig = getImpl().SingleGenericParameterSignature)
     return theSig;

lib/AST/ASTDemangler.cpp

@@ -348,33 +348,6 @@ Type ASTBuilder::createTupleType(ArrayRef<Type> eltTypes,
 Type ASTBuilder::createFunctionType(
     ArrayRef<Demangle::FunctionParam<Type>> params,
     Type output, FunctionTypeFlags flags) {
-  FunctionTypeRepresentation representation;
-  switch (flags.getConvention()) {
-  case FunctionMetadataConvention::Swift:
-    representation = FunctionTypeRepresentation::Swift;
-    break;
-  case FunctionMetadataConvention::Block:
-    representation = FunctionTypeRepresentation::Block;
-    break;
-  case FunctionMetadataConvention::Thin:
-    representation = FunctionTypeRepresentation::Thin;
-    break;
-  case FunctionMetadataConvention::CFunctionPointer:
-    representation = FunctionTypeRepresentation::CFunctionPointer;
-    break;
-  }
-
-  auto einfo = AnyFunctionType::ExtInfo(representation,
-                                        /*throws*/ flags.throws());
-
-  if (representation == FunctionTypeRepresentation::Swift ||
-      representation == FunctionTypeRepresentation::Block) {
-    if (flags.isEscaping())
-      einfo = einfo.withNoEscape(false);
-    else
-      einfo = einfo.withNoEscape(true);
-  }
-
   // The result type must be materializable.
   if (!output->isMaterializable()) return Type();
 
@@ -397,6 +370,42 @@ Type ASTBuilder::createFunctionType(
     funcParams.push_back(AnyFunctionType::Param(type, label, parameterFlags));
   }
 
+  FunctionTypeRepresentation representation;
+  switch (flags.getConvention()) {
+  case FunctionMetadataConvention::Swift:
+    representation = FunctionTypeRepresentation::Swift;
+    break;
+  case FunctionMetadataConvention::Block:
+    representation = FunctionTypeRepresentation::Block;
+    break;
+  case FunctionMetadataConvention::Thin:
+    representation = FunctionTypeRepresentation::Thin;
+    break;
+  case FunctionMetadataConvention::CFunctionPointer:
+    representation = FunctionTypeRepresentation::CFunctionPointer;
+    break;
+  }
+
+  auto noescape =
+    (representation == FunctionTypeRepresentation::Swift
+     || representation == FunctionTypeRepresentation::Block)
+    && !flags.isEscaping();
+
+  FunctionType::ExtInfo incompleteExtInfo(
+    FunctionTypeRepresentation::Swift,
+    noescape, flags.throws(),
+    DifferentiabilityKind::NonDifferentiable,
+    /*clangFunctionType*/nullptr);
+
+  const clang::Type *clangFunctionType = nullptr;
+  if (representation == FunctionTypeRepresentation::CFunctionPointer)
+    clangFunctionType = Ctx.getClangFunctionType(funcParams, output,
+                                                 incompleteExtInfo,
+                                                 representation);
+
+  auto einfo = incompleteExtInfo.withRepresentation(representation)
+                                .withClangFunctionType(clangFunctionType);
+
   return FunctionType::get(funcParams, output, einfo);
 }
 

lib/AST/ASTDumper.cpp

@@ -3608,6 +3608,12 @@ namespace {
 
       OS << "\n";
       Indent += 2;
+      if (auto *cty = T->getClangFunctionType()) {
+        std::string s;
+        llvm::raw_string_ostream os(s);
+        cty->dump(os);
+        printField("clang_type", os.str());
+      }
       printAnyFunctionParams(T->getParams(), "input");
       Indent -=2;
       printRec("output", T->getResult());

lib/AST/CMakeLists.txt

@@ -34,6 +34,7 @@ add_swift_host_library(swiftAST STATIC
   AvailabilitySpec.cpp
   Builtins.cpp
   CaptureInfo.cpp
+  ClangTypeConverter.cpp
   ConcreteDeclRef.cpp
   ConformanceLookupTable.cpp
   Decl.cpp