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

This reverts commit bfa2f98.

Author: varungandhi-apple

include/swift/AST/ASTContext.h

@@ -582,10 +582,6 @@ 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.
@@ -599,15 +595,6 @@ 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,35 +4372,17 @@ Type ASTContext::getBridgedToObjC(const DeclContext *dc, Type type,
   return Type();
 }
 
-void
-ASTContext::initializeClangTypeConverter() {
-  auto &impl = getImpl();
-  if (!impl.Converter) {
-    auto *cml = getClangModuleLoader();
-    impl.Converter.emplace(*this, cml->getClangASTContext(), LangOpts.Target);
-  }
-}
-
 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;
+  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 {

lib/AST/ClangTypeConverter.cpp

@@ -156,57 +156,6 @@ 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,10 +73,6 @@ 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,