[Sema] Parse a Clang function type from the cType argument.

Author: varungandhi-apple

include/swift/AST/ClangModuleLoader.h

@@ -21,6 +21,7 @@ class CompilerInstance;
 class Preprocessor;
 class Sema;
 class TargetInfo;
+class Type;
 } // namespace clang
 
 namespace swift {
@@ -100,6 +101,12 @@ class ClangModuleLoader : public ModuleLoader {
   lookupRelatedEntity(StringRef clangName, ClangTypeKind kind,
                       StringRef relatedEntityKind,
                       llvm::function_ref<void(TypeDecl *)> receiver) = 0;
+
+  /// Try to parse the string as a Clang function type.
+  ///
+  /// Returns null if there was a parsing failure.
+  virtual const clang::Type *parseClangFunctionType(StringRef type,
+                                                    SourceLoc loc) const = 0;
 };
 
 } // namespace swift

include/swift/AST/DiagnosticsSema.def

@@ -3924,6 +3924,13 @@ ERROR(unsupported_convention,none,
       "convention '%0' not supported", (StringRef))
 ERROR(unreferenced_generic_parameter,none,
       "generic parameter '%0' is not used in function signature", (StringRef))
+ERROR(unexpected_ctype_for_non_c_convention,none,
+      "convention '%0' does not support the 'cType' argument label, did you "
+      "mean @convention(c, cType: \"%1\") or @convention(block, cType: \"%1\") "
+      "instead?", (StringRef, StringRef))
+ERROR(unable_to_parse_c_function_type,none,
+      "unable to parse '%0'; it should be a C function pointer type or a "
+      "block pointer type", (StringRef))
 
 // Opaque types
 ERROR(unsupported_opaque_type,none,

include/swift/ClangImporter/ClangImporter.h

@@ -40,6 +40,7 @@ namespace clang {
   class NamedDecl;
   class Sema;
   class TargetInfo;
+  class Type;
   class VisibleDeclConsumer;
   class DeclarationName;
 }
@@ -416,6 +417,9 @@ class ClangImporter final : public ClangModuleLoader {
   /// with -import-objc-header option.
   getPCHFilename(const ClangImporterOptions &ImporterOptions,
                  StringRef SwiftPCHHash, bool &isExplicit);
+
+  const clang::Type *parseClangFunctionType(StringRef type,
+                                            SourceLoc loc) const override;
 };
 
 ImportDecl *createImportDecl(ASTContext &Ctx, DeclContext *DC, ClangNode ClangN,

lib/ClangImporter/ClangImporter.cpp

@@ -3275,6 +3275,23 @@ void ClangImporter::verifyAllModules() {
 #endif
 }
 
+const clang::Type *
+ClangImporter::parseClangFunctionType(StringRef typeStr,
+                                      SourceLoc loc) const {
+  auto &sema = Impl.getClangSema();
+  StringRef filename = Impl.SwiftContext.SourceMgr.getDisplayNameForLoc(loc);
+  // TODO: Obtain a clang::SourceLocation from the swift::SourceLoc we have
+  auto parsedType = sema.ParseTypeFromStringCallback(typeStr, filename, {});
+  if (!parsedType.isUsable())
+    return nullptr;
+  clang::QualType resultType = clang::Sema::GetTypeFromParser(parsedType.get());
+  auto *typePtr = resultType.getTypePtrOrNull();
+  if (typePtr && (typePtr->isFunctionPointerType()
+                  || typePtr->isBlockPointerType()))
+      return typePtr;
+  return nullptr;
+}
+
 //===----------------------------------------------------------------------===//
 // ClangModule Implementation
 //===----------------------------------------------------------------------===//

lib/Sema/TypeCheckType.cpp

@@ -1799,6 +1799,8 @@ namespace {
                                 AnyFunctionType::Representation representation
                                   = AnyFunctionType::Representation::Swift,
                                 bool noescape = false,
+                                const clang::Type *parsedClangFunctionType
+                                  = nullptr,
                                 DifferentiabilityKind diffKind
                                   = DifferentiabilityKind::NonDifferentiable);
     bool
@@ -2166,7 +2168,31 @@ Type TypeResolver::resolveAttributedType(TypeAttributes &attrs,
   // Function attributes require a syntactic function type.
   auto *fnRepr = dyn_cast<FunctionTypeRepr>(repr);
 
+  auto tryParseClangType = [this](TypeAttributes::Convention &conv,
+                                  bool hasConventionCOrBlock)
+                           -> const clang::Type * {
+    if (conv.ClangType.empty())
+      return nullptr;
+    if (!hasConventionCOrBlock) {
+      diagnose(conv.ClangTypeLoc,
+               diag::unexpected_ctype_for_non_c_convention,
+               conv.Name, conv.ClangType);
+      return nullptr;
+    }
+
+    StringRef filename =
+      Context.SourceMgr.getDisplayNameForLoc(conv.ClangTypeLoc);
+    const clang::Type *type = Context.getClangModuleLoader()
+                              ->parseClangFunctionType(conv.ClangType,
+                                                       conv.ClangTypeLoc);
+    if (!type)
+      diagnose(conv.ClangTypeLoc, diag::unable_to_parse_c_function_type,
+               conv.ClangType);
+    return type;
+  };
+
   if (fnRepr && hasFunctionAttr) {
+    const clang::Type *parsedClangFunctionType = nullptr;
     if (options & TypeResolutionFlags::SILType) {
       SILFunctionType::Representation rep;
       TypeRepr *witnessMethodProtocol = nullptr;
@@ -2214,6 +2240,11 @@ Type TypeResolver::resolveAttributedType(TypeAttributes &attrs,
           rep = SILFunctionType::Representation::Thin;
         } else {
           rep = *parsedRep;
+          bool isCOrBlock =
+            rep == SILFunctionTypeRepresentation::CFunctionPointer
+            || rep == SILFunctionTypeRepresentation::Block;
+          parsedClangFunctionType =
+            tryParseClangType(attrs.ConventionArguments.getValue(), isCOrBlock);
         }
 
         if (rep == SILFunctionType::Representation::WitnessMethod) {
@@ -2264,6 +2295,11 @@ Type TypeResolver::resolveAttributedType(TypeAttributes &attrs,
           rep = FunctionType::Representation::Swift;
         } else {
           rep = *parsedRep;
+
+          bool isCOrBlock = rep == FunctionTypeRepresentation::CFunctionPointer
+                          || rep == FunctionTypeRepresentation::Block;
+          parsedClangFunctionType =
+            tryParseClangType(attrs.ConventionArguments.getValue(), isCOrBlock);
         }
       }
 
@@ -2280,6 +2316,7 @@ Type TypeResolver::resolveAttributedType(TypeAttributes &attrs,
       }
 
       ty = resolveASTFunctionType(fnRepr, options, rep, /*noescape=*/false,
+                                  parsedClangFunctionType,
                                   diffKind);
       if (!ty || ty->hasError())
         return ty;
@@ -2593,6 +2630,7 @@ Type TypeResolver::resolveOpaqueReturnType(TypeRepr *repr,
 Type TypeResolver::resolveASTFunctionType(
     FunctionTypeRepr *repr, TypeResolutionOptions parentOptions,
     AnyFunctionType::Representation representation, bool noescape,
+    const clang::Type *parsedClangFunctionType,
     DifferentiabilityKind diffKind) {
 
   TypeResolutionOptions options = None;
@@ -2631,8 +2669,9 @@ Type TypeResolver::resolveASTFunctionType(
                                           noescape, repr->throws(), diffKind,
                                           /*clangFunctionType*/nullptr);
 
-  const clang::Type *clangFnType = nullptr;
-  if (representation == AnyFunctionType::Representation::CFunctionPointer)
+  const clang::Type *clangFnType = parsedClangFunctionType;
+  if (representation == AnyFunctionType::Representation::CFunctionPointer
+      && !clangFnType)
     clangFnType = Context.getClangFunctionType(
       params, outputTy, incompleteExtInfo,
       AnyFunctionType::Representation::CFunctionPointer);

test/Parse/c_function_pointers.swift

@@ -50,8 +50,8 @@ let f: @convention(c) (Int) -> Int = genericFunc // expected-error{{cannot be fo
 
 func ct1() -> () { print("") }
 
-let ct1ref0 : @convention(c, cType: "void *(void)") () -> () = ct1
-let ct1ref1 : @convention(c, cType: "void *(void)") = ct1 // expected-error{{expected type}}
+let ct1ref0 : @convention(c, cType: "void (*)(void)") () -> () = ct1
+let ct1ref1 : @convention(c, cType: "void (*)(void)") = ct1 // expected-error{{expected type}}
 let ct1ref2 : @convention(c, ) () -> () = ct1 // expected-error{{expected 'cType' label in 'convention' attribute}}
 let ct1ref3 : @convention(c, cType) () -> () = ct1 // expected-error{{expected ':' after 'cType' for 'convention' attribute}}
 let ct1ref4 : @convention(c, cType: ) () -> () = ct1 // expected-error{{expected string literal containing clang type for 'cType' in 'convention' attribute}}

test/attr/attr_convention.swift

@@ -2,8 +2,12 @@
 
 let f1: (Int) -> Int = { $0 }
 let f2: @convention(swift) (Int) -> Int = { $0 }
+let f2a: @convention(swift, cType: "int *(int)") (Int32) -> Int32 = { $0 } // expected-error{{convention 'swift' does not support the 'cType' argument label, did you mean @convention(c, cType: "int *(int)") or @convention(block, cType: "int *(int)") instead?}}
 let f3: @convention(block) (Int) -> Int = { $0 }
 let f4: @convention(c) (Int) -> Int = { $0 }
+let f4a: @convention(c, cType: "int (int)") (Int32) -> Int32 = { $0 } // expected-error{{unable to parse 'int (int)'; it should be a C function pointer type or a block pointer type}}
+let f4b: @convention(c, cType: "void *") (Int32) -> Int32 = { $0 } // expected-error{{unable to parse 'void *'; it should be a C function pointer type or a block pointer type}}
+let f4c: @convention(c, cType: "int (*)(int)") (Int32) -> Int32 = { $0 }
 
 let f5: @convention(INTERCAL) (Int) -> Int = { $0 } // expected-error{{convention 'INTERCAL' not supported}}