[AST] Add functionality for computing Clang types for SIL functions.

Author: varungandhi-apple

include/swift/AST/ASTContext.h

@@ -576,6 +576,10 @@ class ASTContext final {
   Type getBridgedToObjC(const DeclContext *dc, Type type,
                         Type *bridgedValueType = nullptr) const;
 
+private:
+  void initializeClangTypeConverter();
+
+public:
   /// Get the Clang type corresponding to a Swift function type.
   ///
   /// \param params The function parameters.
@@ -589,6 +593,15 @@ class ASTContext final {
                        const FunctionType::ExtInfo incompleteExtInfo,
                        FunctionTypeRepresentation trueRep);
 
+  /// Get the canonical Clang type corresponding to a SIL function type.
+  ///
+  /// SIL analog of \c ASTContext::getClangFunctionType .
+  const clang::Type *
+  getCanonicalClangFunctionType(
+    ArrayRef<SILParameterInfo> params, Optional<SILResultInfo> result,
+    const SILFunctionType::ExtInfo incompleteExtInfo,
+    SILFunctionType::Representation trueRep);
+
   /// Determine whether the given Swift type is representable in a
   /// given foreign language.
   ForeignRepresentationInfo

lib/AST/ASTContext.cpp

@@ -4372,17 +4372,35 @@ 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) {
+void
+ASTContext::initializeClangTypeConverter() {
   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);
+}
+
+const clang::Type *
+ASTContext::getClangFunctionType(ArrayRef<AnyFunctionType::Param> params,
+                                 Type resultTy,
+                                 FunctionType::ExtInfo incompleteExtInfo,
+                                 FunctionTypeRepresentation trueRep) {
+  initializeClangTypeConverter();
+  return getImpl().Converter.getValue().getFunctionType(params, resultTy,
+                                                        trueRep);
+}
+
+const clang::Type *
+ASTContext::getCanonicalClangFunctionType(
+    ArrayRef<SILParameterInfo> params,
+    Optional<SILResultInfo> result,
+    SILFunctionType::ExtInfo incompleteExtInfo,
+    SILFunctionType::Representation trueRep) {
+  initializeClangTypeConverter();
+  auto *ty = getImpl().Converter.getValue().getFunctionType(params, result,
+                                                            trueRep);
+  return ty ? ty->getCanonicalTypeInternal().getTypePtr() : nullptr;
 }
 
 CanGenericSignature ASTContext::getSingleGenericParameterSignature() const {

lib/AST/ClangTypeConverter.cpp

@@ -156,6 +156,57 @@ const clang::Type *ClangTypeConverter::getFunctionType(
   }
 }
 
+const clang::Type *ClangTypeConverter::getFunctionType(
+    ArrayRef<SILParameterInfo> params, Optional<SILResultInfo> result,
+    SILFunctionType::Representation repr) {
+
+  // Using the interface type is sufficient as Swift does not allow abstracting
+  // over @convention(c) functions, hence we don't need any substitutions.
+  auto resultClangTy = result.hasValue()
+                     ? convert(result.getValue().getInterfaceType())
+                     : ClangASTContext.VoidTy;
+
+  if (resultClangTy.isNull())
+    return nullptr;
+
+  SmallVector<clang::FunctionProtoType::ExtParameterInfo, 4> extParamInfos;
+  SmallVector<clang::QualType, 4> paramsClangTy;
+  bool someParamIsConsumed = false;
+  for (auto &p : params) {
+    auto pc = convert(p.getInterfaceType());
+    if (pc.isNull())
+      return nullptr;
+    clang::FunctionProtoType::ExtParameterInfo extParamInfo;
+    if (p.isConsumed()) {
+      someParamIsConsumed = true;
+      extParamInfo = extParamInfo.withIsConsumed(true);
+    }
+    extParamInfos.push_back(extParamInfo);
+    paramsClangTy.push_back(pc);
+  }
+
+  clang::FunctionProtoType::ExtProtoInfo info(clang::CallingConv::CC_C);
+  if (someParamIsConsumed)
+    info.ExtParameterInfos = extParamInfos.begin();
+  auto fn = ClangASTContext.getFunctionType(resultClangTy, paramsClangTy, info);
+  if (fn.isNull())
+    return nullptr;
+
+  switch (repr) {
+  case SILFunctionType::Representation::CFunctionPointer:
+    return ClangASTContext.getPointerType(fn).getTypePtr();
+  case SILFunctionType::Representation::Block:
+    return ClangASTContext.getBlockPointerType(fn).getTypePtr();
+  case SILFunctionType::Representation::Thick:
+  case SILFunctionType::Representation::Thin:
+  case SILFunctionType::Representation::Method:
+  case SILFunctionType::Representation::ObjCMethod:
+  case SILFunctionType::Representation::WitnessMethod:
+  case SILFunctionType::Representation::Closure:
+    llvm_unreachable("Expected a C-compatible representation.");
+  }
+}
+
 clang::QualType ClangTypeConverter::convertMemberType(NominalTypeDecl *DC,
                                                       StringRef memberName) {
   auto memberTypeDecl = cast<TypeDecl>(

lib/AST/ClangTypeConverter.h

@@ -73,6 +73,10 @@ class ClangTypeConverter :
     ArrayRef<AnyFunctionType::Param> params, Type resultTy,
     AnyFunctionType::Representation repr);
 
+  const clang::Type *getFunctionType(
+    ArrayRef<SILParameterInfo> params, Optional<SILResultInfo> result,
+    SILFunctionType::Representation repr);
+
 private:
   clang::QualType convert(Type type);
   clang::QualType convertMemberType(NominalTypeDecl *DC,