Merge pull request #2065 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

docs/ABI/Mangling.rst

@@ -523,15 +523,20 @@ Types
   FUNCTION-KIND ::= 'U'                      // uncurried function type (currently not used)
   FUNCTION-KIND ::= 'K'                      // @auto_closure function type (noescape)
   FUNCTION-KIND ::= 'B'                      // objc block function type
-  FUNCTION-KIND ::= 'L'                      // objc block function type (escaping) (DWARF only; otherwise use 'B')
+  FUNCTION-KIND ::= 'zB' C-TYPE              // objc block type with non-canonical C type
+  FUNCTION-KIND ::= 'L'                      // objc block function type with canonical C type (escaping) (DWARF only; otherwise use 'B' or 'zB' C-TYPE)
   FUNCTION-KIND ::= 'C'                      // C function pointer type
+  FUNCTION-KIND ::= 'zC' C-TYPE              // C function pointer type with with non-canonical C type
   FUNCTION-KIND ::= 'A'                      // @auto_closure function type (escaping)
   FUNCTION-KIND ::= 'E'                      // function type (noescape)
   FUNCTION-KIND ::= 'F'                      // @differentiable function type
   FUNCTION-KIND ::= 'G'                      // @differentiable function type (escaping)
   FUNCTION-KIND ::= 'H'                      // @differentiable(linear) function type
   FUNCTION-KIND ::= 'I'                      // @differentiable(linear) function type (escaping)
 
+  C-TYPE is mangled according to the Itanium ABI, and prefixed with the length.
+  Non-ASCII identifiers are preserved as-is; we do not use Punycode.
+
   function-signature ::= params-type params-type async? throws? // results and parameters
 
   params-type ::= type 'z'? 'h'?              // tuple in case of multiple parameters or a single parameter with a single tuple type
@@ -618,7 +623,9 @@ mangled in to disambiguate.
   CALLEE-CONVENTION ::= 't'                  // thin
 
   FUNC-REPRESENTATION ::= 'B'                // C block invocation function
+  FUNC-REPRESENTATION ::= 'zB' C-TYPE        // C block invocation function with non-canonical C type
   FUNC-REPRESENTATION ::= 'C'                // C global function
+  FUNC-REPRESENTATION ::= 'zC' C-TYPE        // C global function with non-canonical C type
   FUNC-REPRESENTATION ::= 'M'                // Swift method
   FUNC-REPRESENTATION ::= 'J'                // ObjC method
   FUNC-REPRESENTATION ::= 'K'                // closure

include/swift/AST/ASTContext.h

@@ -23,11 +23,12 @@
 #include "swift/AST/Import.h"
 #include "swift/AST/SearchPathOptions.h"
 #include "swift/AST/Type.h"
-#include "swift/AST/Types.h"
 #include "swift/AST/TypeAlignments.h"
+#include "swift/AST/Types.h"
 #include "swift/Basic/LangOptions.h"
 #include "swift/Basic/Located.h"
 #include "swift/Basic/Malloc.h"
+#include "clang/AST/DeclTemplate.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
@@ -628,6 +629,13 @@ class ASTContext final {
     ArrayRef<SILParameterInfo> params, Optional<SILResultInfo> result,
     SILFunctionType::Representation trueRep);
 
+  /// Instantiates "Impl.Converter" if needed, then calls
+  /// ClangTypeConverter::getClangTemplateArguments.
+  std::unique_ptr<TemplateInstantiationError> getClangTemplateArguments(
+      const clang::TemplateParameterList *templateParams,
+      ArrayRef<Type> genericArgs,
+      SmallVectorImpl<clang::TemplateArgument> &templateArgs);
+
   /// Get the Swift declaration that a Clang declaration was exported from,
   /// if applicable.
   const Decl *getSwiftDeclForExportedClangDecl(const clang::Decl *decl);

include/swift/AST/ASTMangler.h

@@ -318,6 +318,9 @@ class ASTMangler : public Mangler {
                       const ValueDecl *forDecl = nullptr);
   void appendFunctionType(AnyFunctionType *fn, bool isAutoClosure = false,
                           const ValueDecl *forDecl = nullptr);
+  void appendClangType(AnyFunctionType *fn);
+  template <typename FnType>
+  void appendClangType(FnType *fn, llvm::raw_svector_ostream &os);
 
   void appendFunctionSignature(AnyFunctionType *fn,
                                const ValueDecl *forDecl = nullptr);

include/swift/AST/ClangModuleLoader.h

@@ -14,7 +14,9 @@
 #define SWIFT_AST_CLANG_MODULE_LOADER_H
 
 #include "swift/AST/ModuleLoader.h"
+#include "swift/AST/SubstitutionMap.h"
 #include "swift/Basic/TaggedUnion.h"
+#include "clang/AST/DeclTemplate.h"
 
 namespace clang {
 class ASTContext;
@@ -219,6 +221,18 @@ class ClangModuleLoader : public ModuleLoader {
   /// based on subtleties like the target module interface format.
   virtual bool isSerializable(const clang::Type *type,
                               bool checkCanonical) const = 0;
+
+  virtual clang::FunctionDecl *
+  instantiateCXXFunctionTemplate(ASTContext &ctx,
+                                 clang::FunctionTemplateDecl *func,
+                                 SubstitutionMap subst) = 0;
+};
+
+/// Used to describe a template instantiation error.
+struct TemplateInstantiationError {
+  /// Generic types that could not be converted to QualTypes using the
+  /// ClangTypeConverter.
+  SmallVector<Type, 4> failedTypes;
 };
 
 } // namespace swift

include/swift/AST/Decl.h

@@ -5960,9 +5960,10 @@ class FuncDecl : public AbstractFunctionDecl {
                                   DeclContext *Parent);
 
   static FuncDecl *createImported(ASTContext &Context, SourceLoc FuncLoc,
-                                  DeclName Name, SourceLoc NameLoc,
-                                  bool Async, bool Throws,
-                                  ParameterList *BodyParams, Type FnRetType,
+                                  DeclName Name, SourceLoc NameLoc, bool Async,
+                                  bool Throws, ParameterList *BodyParams,
+                                  Type FnRetType,
+                                  GenericParamList *GenericParams,
                                   DeclContext *Parent, ClangNode ClangN);
 
   bool isStatic() const;

include/swift/AST/DiagnosticsSema.def

@@ -1674,6 +1674,11 @@ ERROR(where_nongeneric_ctx,none,
 ERROR(where_nongeneric_toplevel,none,
       "'where' clause cannot be applied to a non-generic top-level "
       "declaration", ())
+ERROR(unable_to_convert_generic_swift_types,none,
+      "could not generate C++ types from the generic Swift types provided. "
+      "The following Swift type(s) provided to '%0' were unable to be "
+      "converted: %1.",
+      (StringRef, StringRef))
 
 // Type aliases
 ERROR(type_alias_underlying_type_access,none,

include/swift/AST/ExtInfo.h

@@ -70,6 +70,7 @@ class ClangTypeInfo {
   constexpr ClangTypeInfo(const clang::Type *type) : type(type) {}
 
   friend bool operator==(ClangTypeInfo lhs, ClangTypeInfo rhs);
+  friend bool operator!=(ClangTypeInfo lhs, ClangTypeInfo rhs);
   ClangTypeInfo getCanonical() const;
 
 public:

include/swift/AST/Types.h

@@ -2926,6 +2926,24 @@ class AnyFunctionType : public TypeBase {
   ClangTypeInfo getClangTypeInfo() const;
   ClangTypeInfo getCanonicalClangTypeInfo() const;
 
+  /// Returns true if the function type stores a Clang type that cannot
+  /// be derived from its Swift type. Returns false otherwise, including if
+  /// the function type is not @convention(c) or @convention(block).
+  ///
+  /// For example, if you have a function pointer from C getting imported with
+  /// the following type:
+  ///
+  /// @convention(c, cType: "void (*)(size_t (*)(size_t))")
+  ///   (@convention(c, cType: "size_t (*)(size_t)") (Int) -> Int)) -> Void
+  ///
+  /// The parameter's function type will have hasNonDerivableClangType() = true,
+  /// but the outer function type will have hasNonDerivableClangType() = false,
+  /// because the parameter and result type are sufficient to correctly derive
+  /// the Clang type for the outer function type. In terms of mangling,
+  /// the parameter type's mangling will incorporate the Clang type but the
+  /// outer function type's mangling doesn't need to duplicate that information.
+  bool hasNonDerivableClangType();
+
   ExtInfo getExtInfo() const {
     return ExtInfo(Bits.AnyFunctionType.ExtInfoBits, getClangTypeInfo());
   }
@@ -4307,6 +4325,11 @@ class SILFunctionType final
 
   ClangTypeInfo getClangTypeInfo() const;
 
+  /// Returns true if the function type stores a Clang type that cannot
+  /// be derived from its Swift type. Returns false otherwise, including if
+  /// the function type is not @convention(c) or @convention(block).
+  bool hasNonDerivableClangType();
+
   bool hasSameExtInfoAs(const SILFunctionType *otherFn);
 
   /// Given that `this` is a `@differentiable` or `@differentiable(linear)`

include/swift/ClangImporter/ClangImporter.h

@@ -472,6 +472,11 @@ class ClangImporter final : public ClangModuleLoader {
 
   bool isSerializable(const clang::Type *type,
                       bool checkCanonical) const override;
+
+  clang::FunctionDecl *
+  instantiateCXXFunctionTemplate(ASTContext &ctx,
+                                 clang::FunctionTemplateDecl *func,
+                                 SubstitutionMap subst) override;
 };
 
 ImportDecl *createImportDecl(ASTContext &Ctx, DeclContext *DC, ClangNode ClangN,

include/swift/Demangling/DemangleNodes.def

@@ -44,6 +44,7 @@ NODE(BoundGenericTypeAlias)
 NODE(BoundGenericFunction)
 NODE(BuiltinTypeName)
 NODE(CFunctionPointer)
+NODE(ClangType)
 CONTEXT_NODE(Class)
 NODE(ClassMetadataBaseOffset)
 NODE(ConcreteProtocolConformance)
@@ -120,6 +121,8 @@ NODE(ImplEscaping)
 NODE(ImplConvention)
 NODE(ImplDifferentiability)
 NODE(ImplFunctionAttribute)
+NODE(ImplFunctionConvention)
+NODE(ImplFunctionConventionName)
 NODE(ImplFunctionType)
 NODE(ImplInvocationSubstitutions)
 CONTEXT_NODE(ImplicitClosure)

include/swift/Demangling/Demangler.h

@@ -505,7 +505,7 @@ class Demangler : public NodeFactory {
   NodePointer demangleAnyGenericType(Node::Kind kind);
   NodePointer demangleExtensionContext();
   NodePointer demanglePlainFunction();
-  NodePointer popFunctionType(Node::Kind kind);
+  NodePointer popFunctionType(Node::Kind kind, bool hasClangType = false);
   NodePointer popFunctionParams(Node::Kind kind);
   NodePointer popFunctionParamLabels(NodePointer FuncType);
   NodePointer popTuple();
@@ -522,6 +522,7 @@ class Demangler : public NodeFactory {
   NodePointer demangleImplResultConvention(Node::Kind ConvKind);
   NodePointer demangleImplDifferentiability();
   NodePointer demangleImplFunctionType();
+  NodePointer demangleClangType();
   NodePointer demangleMetatype();
   NodePointer demanglePrivateContextDescriptor();
   NodePointer createArchetypeRef(int depth, int i);

include/swift/Demangling/TypeDecoder.h

@@ -631,6 +631,12 @@ class TypeDecoder {
       }
 
       unsigned firstChildIdx = 0;
+      if (Node->getChild(firstChildIdx)->getKind() == NodeKind::ClangType) {
+        // [TODO: synthesize-Clang-type-from-mangled-name] Use the first child
+        // to create a ClangTypeInfo.
+        ++firstChildIdx;
+      }
+
       bool isThrow = false;
       if (Node->getChild(firstChildIdx)->getKind()
             == NodeKind::ThrowsAnnotation) {
@@ -695,18 +701,28 @@ class TypeDecoder {
           } else if (child->getText() == "@callee_guaranteed") {
             calleeConvention = ImplParameterConvention::Direct_Guaranteed;
           }
-        } else if (child->getKind() == NodeKind::ImplFunctionAttribute) {
-          if (!child->hasText())
-            return MAKE_NODE_TYPE_ERROR0(child, "expected text");
-
-          StringRef text = child->getText();
-          if (text == "@convention(c)") {
+        } else if (child->getKind() == NodeKind::ImplFunctionConvention) {
+          if (child->getNumChildren() == 0)
+            return MAKE_NODE_TYPE_ERROR0(child, "expected grandchildren");
+          if ((child->getFirstChild()->getKind() !=
+               NodeKind::ImplFunctionConventionName) ||
+              !child->getFirstChild()->hasText())
+            return MAKE_NODE_TYPE_ERROR0(child, "expected convention name");
+
+          // [TODO: synthesize-Clang-type-from-mangled-name] If there are two
+          // grand-children, the second is going to be the mangled Clang type.
+          StringRef text = child->getFirstChild()->getText();
+          if (text == "c") {
             flags =
               flags.withRepresentation(ImplFunctionRepresentation::CFunctionPointer);
-          } else if (text == "@convention(block)") {
+          } else if (text == "block") {
             flags =
               flags.withRepresentation(ImplFunctionRepresentation::Block);
-          } else if (text == "@async") {
+          }
+        } else if (child->getKind() == NodeKind::ImplFunctionAttribute) {
+          if (!child->hasText())
+            return MAKE_NODE_TYPE_ERROR0(child, "expected text");
+          if (child->getText() == "@async") {
             flags = flags.withAsync();
           }
         } else if (child->getKind() == NodeKind::ImplDifferentiable) {

lib/AST/ASTContext.cpp

@@ -18,13 +18,13 @@
 #include "ClangTypeConverter.h"
 #include "ForeignRepresentationInfo.h"
 #include "SubstitutionMapStorage.h"
-#include "swift/AST/ForeignAsyncConvention.h"
 #include "swift/AST/ClangModuleLoader.h"
 #include "swift/AST/ConcreteDeclRef.h"
 #include "swift/AST/DiagnosticEngine.h"
 #include "swift/AST/DiagnosticsSema.h"
 #include "swift/AST/ExistentialLayout.h"
 #include "swift/AST/FileUnit.h"
+#include "swift/AST/ForeignAsyncConvention.h"
 #include "swift/AST/ForeignErrorConvention.h"
 #include "swift/AST/GenericEnvironment.h"
 #include "swift/AST/GenericSignature.h"
@@ -41,19 +41,19 @@
 #include "swift/AST/PropertyWrappers.h"
 #include "swift/AST/ProtocolConformance.h"
 #include "swift/AST/RawComment.h"
+#include "swift/AST/SILLayout.h"
 #include "swift/AST/SemanticAttrs.h"
 #include "swift/AST/SourceFile.h"
 #include "swift/AST/SubstitutionMap.h"
-#include "swift/AST/SILLayout.h"
 #include "swift/AST/TypeCheckRequests.h"
 #include "swift/Basic/Compiler.h"
 #include "swift/Basic/SourceManager.h"
 #include "swift/Basic/Statistic.h"
 #include "swift/Basic/StringExtras.h"
-#include "swift/Syntax/References.h"
-#include "swift/Syntax/SyntaxArena.h"
 #include "swift/Strings.h"
 #include "swift/Subsystems.h"
+#include "swift/Syntax/References.h"
+#include "swift/Syntax/SyntaxArena.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/ADT/StringMap.h"
@@ -4563,6 +4563,21 @@ ASTContext::getCanonicalClangFunctionType(
   return ty ? ty->getCanonicalTypeInternal().getTypePtr() : nullptr;
 }
 
+std::unique_ptr<TemplateInstantiationError>
+ASTContext::getClangTemplateArguments(
+    const clang::TemplateParameterList *templateParams,
+    ArrayRef<Type> genericArgs,
+    SmallVectorImpl<clang::TemplateArgument> &templateArgs) {
+  auto &impl = getImpl();
+  if (!impl.Converter) {
+    auto *cml = getClangModuleLoader();
+    impl.Converter.emplace(*this, cml->getClangASTContext(), LangOpts.Target);
+  }
+
+  return impl.Converter->getClangTemplateArguments(templateParams, genericArgs,
+                                                   templateArgs);
+}
+
 const Decl *
 ASTContext::getSwiftDeclForExportedClangDecl(const clang::Decl *decl) {
   auto &impl = getImpl();