Merge pull request #67368 from rjmccall/unimplementable-variadic-reabstraction

Diagnose attempts to reabstract variadic functions in unimplementable ways

Author: rjmccall

include/swift/AST/Attr.def.gyb

@@ -86,6 +86,7 @@ TYPE_ATTR(objc_metatype)
 TYPE_ATTR(opened)
 TYPE_ATTR(pack_element)
 TYPE_ATTR(pseudogeneric)
+TYPE_ATTR(unimplementable)
 TYPE_ATTR(yields)
 TYPE_ATTR(yield_once)
 TYPE_ATTR(yield_many)

include/swift/AST/CASTBridging.h

@@ -190,6 +190,7 @@ typedef enum ENUM_EXTENSIBILITY_ATTR(closed) BridgedTypeAttrKind : long {
   BridgedTypeAttrKind_opened,
   BridgedTypeAttrKind_pack_element,
   BridgedTypeAttrKind_pseudogeneric,
+  BridgedTypeAttrKind_unimplementable,
   BridgedTypeAttrKind_yields,
   BridgedTypeAttrKind_yield_once,
   BridgedTypeAttrKind_yield_many,

include/swift/AST/DiagnosticsSIL.def

@@ -115,6 +115,12 @@ ERROR(c_function_pointer_from_function_with_context,none,
 ERROR(objc_selector_malformed,none,"the type ObjectiveC.Selector is malformed",
       ())
 
+ERROR(unsupported_variadic_function_abstraction,none,
+      "cannot fully abstract a value of variadic function type %0 because "
+      "different contexts will not be able to reliably agree on a calling "
+      "convention; try wrapping it in a struct",
+      (Type))
+
 // Capture before declaration diagnostics.
 ERROR(capture_before_declaration,none,
       "closure captures %0 before it is declared", (Identifier))

include/swift/AST/ExtInfo.h

@@ -651,8 +651,10 @@ class SILExtInfoBuilder {
   // If bits are added or removed, then TypeBase::SILFunctionTypeBits
   // and NumMaskBits must be updated, and they must match.
 
-  //   |representation|pseudogeneric| noescape | concurrent | async |differentiability|
-  //   |    0 .. 3    |      4      |     5    |     6      |   7   |     8 .. 10     |
+  //   |representation|pseudogeneric| noescape | concurrent | async
+  //   |    0 .. 3    |      4      |     5    |     6      |   7
+  //   |differentiability|unimplementable|
+  //   |     8 .. 10     |      11       |
   //
   enum : unsigned {
     RepresentationMask = 0xF << 0,
@@ -662,7 +664,8 @@ class SILExtInfoBuilder {
     AsyncMask = 1 << 7,
     DifferentiabilityMaskOffset = 8,
     DifferentiabilityMask = 0x7 << DifferentiabilityMaskOffset,
-    NumMaskBits = 11
+    UnimplementableMask = 1 << 11,
+    NumMaskBits = 12
   };
 
   unsigned bits; // Naturally sized for speed.
@@ -677,12 +680,13 @@ class SILExtInfoBuilder {
 
   static constexpr unsigned makeBits(Representation rep, bool isPseudogeneric,
                                      bool isNoEscape, bool isSendable,
-                                     bool isAsync,
+                                     bool isAsync, bool isUnimplementable,
                                      DifferentiabilityKind diffKind) {
     return ((unsigned)rep) | (isPseudogeneric ? PseudogenericMask : 0) |
            (isNoEscape ? NoEscapeMask : 0) |
            (isSendable ? SendableMask : 0) |
            (isAsync ? AsyncMask : 0) |
+           (isUnimplementable ? UnimplementableMask : 0) |
            (((unsigned)diffKind << DifferentiabilityMaskOffset) &
             DifferentiabilityMask);
   }
@@ -692,22 +696,23 @@ class SILExtInfoBuilder {
   /// non-pseudogeneric, non-differentiable.
   SILExtInfoBuilder()
       : SILExtInfoBuilder(makeBits(SILFunctionTypeRepresentation::Thick, false,
-                                   false, false, false,
+                                   false, false, false, false,
                                    DifferentiabilityKind::NonDifferentiable),
                           ClangTypeInfo(nullptr)) {}
 
   SILExtInfoBuilder(Representation rep, bool isPseudogeneric, bool isNoEscape,
-                    bool isSendable, bool isAsync,
+                    bool isSendable, bool isAsync, bool isUnimplementable,
                     DifferentiabilityKind diffKind, const clang::Type *type)
       : SILExtInfoBuilder(makeBits(rep, isPseudogeneric, isNoEscape,
-                                   isSendable, isAsync, diffKind),
+                                   isSendable, isAsync, isUnimplementable,
+                                   diffKind),
                           ClangTypeInfo(type)) {}
 
   // Constructor for polymorphic type.
   SILExtInfoBuilder(ASTExtInfoBuilder info, bool isPseudogeneric)
       : SILExtInfoBuilder(makeBits(info.getSILRepresentation(), isPseudogeneric,
                                    info.isNoEscape(), info.isSendable(),
-                                   info.isAsync(),
+                                   info.isAsync(), /*unimplementable*/ false,
                                    info.getDifferentiabilityKind()),
                           info.getClangTypeInfo()) {}
 
@@ -746,6 +751,10 @@ class SILExtInfoBuilder {
            DifferentiabilityKind::NonDifferentiable;
   }
 
+  constexpr bool isUnimplementable() const {
+    return bits & UnimplementableMask;
+  }
+
   /// Get the underlying ClangTypeInfo value.
   ClangTypeInfo getClangTypeInfo() const { return clangTypeInfo; }
 
@@ -816,6 +825,12 @@ class SILExtInfoBuilder {
                              clangTypeInfo);
   }
   [[nodiscard]]
+  SILExtInfoBuilder withUnimplementable(bool isUnimplementable = true) const {
+    return SILExtInfoBuilder(isUnimplementable ? (bits | UnimplementableMask)
+                                               : (bits & ~UnimplementableMask),
+                             clangTypeInfo);
+  }
+  [[nodiscard]]
   SILExtInfoBuilder
   withDifferentiabilityKind(DifferentiabilityKind differentiability) const {
     return SILExtInfoBuilder(
@@ -828,6 +843,7 @@ class SILExtInfoBuilder {
     return SILExtInfoBuilder(bits, ClangTypeInfo(type).getCanonical());
   }
 
+
   bool isEqualTo(SILExtInfoBuilder other, bool useClangTypes) const {
     return bits == other.bits &&
            (useClangTypes ? (clangTypeInfo == other.clangTypeInfo) : true);
@@ -873,7 +889,7 @@ class SILExtInfo {
   /// A default ExtInfo but with a Thin convention.
   static SILExtInfo getThin() {
     return SILExtInfoBuilder(SILExtInfoBuilder::Representation::Thin, false,
-                             false, false, false,
+                             false, false, false, false,
                              DifferentiabilityKind::NonDifferentiable, nullptr)
         .build();
   }
@@ -901,6 +917,10 @@ class SILExtInfo {
 
   constexpr bool isAsync() const { return builder.isAsync(); }
 
+  constexpr bool isUnimplementable() const {
+    return builder.isUnimplementable();
+  }
+
   constexpr DifferentiabilityKind getDifferentiabilityKind() const {
     return builder.getDifferentiabilityKind();
   }
@@ -935,6 +955,10 @@ class SILExtInfo {
     return builder.withAsync(isAsync).build();
   }
 
+  SILExtInfo withUnimplementable(bool isUnimplementable = true) const {
+    return builder.withUnimplementable(isUnimplementable).build();
+  }
+
   bool isEqualTo(SILExtInfo other, bool useClangTypes) const {
     return builder.isEqualTo(other.builder, useClangTypes);
   }

include/swift/AST/Types.h

@@ -375,7 +375,7 @@ class alignas(1 << TypeAlignInBits) TypeBase
 
 protected:
   enum { NumAFTExtInfoBits = 11 };
-  enum { NumSILExtInfoBits = 11 };
+  enum { NumSILExtInfoBits = 12 };
 
   // clang-format off
   union { uint64_t OpaqueBits;
@@ -3561,6 +3561,10 @@ class AnyFunctionType : public TypeBase {
   /// replaced.
   AnyFunctionType *withExtInfo(ExtInfo info) const;
 
+  bool containsPackExpansionParam() const {
+    return containsPackExpansionType(getParams());
+  }
+
   static bool containsPackExpansionType(ArrayRef<Param> params);
 
   static void printParams(ArrayRef<Param> Params, raw_ostream &OS,
@@ -4621,6 +4625,7 @@ class SILFunctionType final
   }
 
   bool isSendable() const { return getExtInfo().isSendable(); }
+  bool isUnimplementable() const { return getExtInfo().isUnimplementable(); }
   bool isAsync() const { return getExtInfo().isAsync(); }
 
   /// Return the array of all the yields.

include/swift/SIL/AbstractionPattern.h

@@ -1625,7 +1625,8 @@ class AbstractionPattern {
   getSubstFunctionTypePattern(CanAnyFunctionType substType,
                               TypeConverter &TC,
                               AbstractionPattern coroutineYieldOrigType,
-                              CanType coroutineYieldSubstType) const;
+                              CanType coroutineYieldSubstType,
+                              bool &unimplementable) const;
 
   void dump() const LLVM_ATTRIBUTE_USED;
   void print(raw_ostream &OS) const;

include/swift/SIL/AbstractionPatternGenerators.h

@@ -136,6 +136,18 @@ class FunctionParamGenerator {
     return origParamIsExpansion;
   }
 
+  /// Return whether the current substituted parameter is a pack
+  /// expansion but the orig function type is opaque.  This is
+  /// unimplementable in our ABI because the calling convention for
+  /// function types in the most-general abstraction pattern still
+  /// assumes a fixed arity.
+  bool isUnimplementablePackExpansion() const {
+    assert(!isFinished());
+    return (origFunctionTypeIsOpaque &&
+            isa<PackExpansionType>(
+              allSubstParams[substParamIndex].getParameterType()));
+  }
+
   /// Return the substituted parameters corresponding to the current
   /// orig parameter type.  If the current orig parameter is not a
   /// pack expansion, this will have exactly one element.

lib/AST/ASTDemangler.cpp

@@ -574,6 +574,10 @@ Type ASTBuilder::createImplFunctionType(
   #undef SIMPLE_CASE
   }
 
+  // There's no representation of this in the mangling because it can't
+  // occur in well-formed programs.
+  bool unimplementable = false;
+
   llvm::SmallVector<SILParameterInfo, 8> funcParams;
   llvm::SmallVector<SILYieldInfo, 8> funcYields;
   llvm::SmallVector<SILResultInfo, 8> funcResults;
@@ -610,7 +614,8 @@ Type ASTBuilder::createImplFunctionType(
   }
   auto einfo = SILFunctionType::ExtInfoBuilder(
                    representation, flags.isPseudogeneric(), !flags.isEscaping(),
-                   flags.isSendable(), flags.isAsync(), diffKind, clangFnType)
+                   flags.isSendable(), flags.isAsync(),
+                   unimplementable, diffKind, clangFnType)
                    .build();
 
   return SILFunctionType::get(genericSig, einfo, funcCoroutineKind,

lib/AST/ASTPrinter.cpp

@@ -6527,6 +6527,9 @@ class TypePrinter : public TypeVisitor<TypePrinter> {
       Printer << " ";
     }
 
+    if (info.isUnimplementable()) {
+      Printer.printSimpleAttr("@unimplementable") << " ";
+    }
     if (info.isPseudogeneric()) {
       Printer.printSimpleAttr("@pseudogeneric") << " ";
     }

lib/ASTGen/Sources/ASTGen/Types.swift

@@ -222,7 +222,8 @@ extension ASTGenVisitor {
           case .autoclosure, .escaping, .noescape, .noDerivative, .async,
             .sendable, .unchecked, ._local, ._noMetadata, .pack_owned,
             .pack_guaranteed, .pack_inout, .pack_out, .pseudogeneric,
-            .yields, .yield_once, .yield_many, .thin, .thick, .count:
+            .yields, .yield_once, .yield_many, .thin, .thick, .count,
+            .unimplementable:
             TypeAttributes_addSimpleAttr(typeAttributes, typeAttrKind, atLoc, attrLoc)
 
           case .opened, .pack_element, .differentiable, .convention,