[5.9] Diagnose attempts to reabstract variadic function types in unimplementable ways

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/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,8 @@ class alignas(1 << TypeAlignInBits) TypeBase
 
 protected:
   enum { NumAFTExtInfoBits = 11 };
-  enum { NumSILExtInfoBits = 11 };
+  enum { NumSILExtInfoBits = 12 };
+
   union { uint64_t OpaqueBits;
 
   SWIFT_INLINE_BITFIELD_BASE(TypeBase, bitmax(NumTypeKindBits,8) +
@@ -3558,6 +3559,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,
@@ -4618,6 +4623,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

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

lib/SIL/IR/AbstractionPattern.cpp

@@ -1950,9 +1950,10 @@ class SubstFunctionTypePatternVisitor
   SmallVector<Type, 2> substReplacementTypes;
   CanType substYieldType;
   unsigned packExpansionLevel;
+  bool &unimplementable;
 
-  SubstFunctionTypePatternVisitor(TypeConverter &TC)
-    : TC(TC), packExpansionLevel(0) {}
+  SubstFunctionTypePatternVisitor(TypeConverter &TC, bool &unimplementable)
+    : TC(TC), packExpansionLevel(0), unimplementable(unimplementable) {}
 
   // Creates and returns a fresh type parameter in the substituted generic
   // signature if `pattern` is a type parameter or opaque archetype. Returns
@@ -2358,7 +2359,10 @@ class SubstFunctionTypePatternVisitor
 
     pattern.forEachFunctionParam(func.getParams(), /*ignore self*/ false,
                                  [&](FunctionParamGenerator &param) {
-      if (!param.isOrigPackExpansion()) {
+      if (param.isUnimplementablePackExpansion()) {
+        unimplementable = true;
+        // Just ignore it.
+      } else if (!param.isOrigPackExpansion()) {
         auto newParamTy = visit(param.getSubstParams()[0].getParameterType(),
                                 param.getOrigType());
         addParam(param.getOrigFlags(), newParamTy);
@@ -2401,7 +2405,8 @@ std::tuple<AbstractionPattern, SubstitutionMap, AbstractionPattern>
 AbstractionPattern::getSubstFunctionTypePattern(CanAnyFunctionType substType,
                                                 TypeConverter &TC,
                                                 AbstractionPattern origYieldType,
-                                                CanType substYieldType)
+                                                CanType substYieldType,
+                                                bool &unimplementable)
 const {
   // If this abstraction pattern isn't meaningfully generic, then we don't
   // need to do any transformation.
@@ -2419,7 +2424,7 @@ const {
               : AbstractionPattern::getInvalid());
   }
 
-  SubstFunctionTypePatternVisitor visitor(TC);
+  SubstFunctionTypePatternVisitor visitor(TC, unimplementable);
   auto substTy = visitor.handleUnabstractedFunctionType(substType, *this,
                                                         substYieldType,
                                                         origYieldType);

lib/SIL/IR/SILFunctionType.cpp

@@ -1504,8 +1504,9 @@ class DestructureInputs {
 
   void destructure(AbstractionPattern origType,
                    CanAnyFunctionType::CanParamArrayRef params,
-                   SILExtInfoBuilder extInfoBuilder) {
-    visitTopLevelParams(origType, params, extInfoBuilder);
+                   SILExtInfoBuilder extInfoBuilder,
+                   bool &unimplementable) {
+    visitTopLevelParams(origType, params, extInfoBuilder, unimplementable);
   }
 
 private:
@@ -1528,7 +1529,8 @@ class DestructureInputs {
   ///     is still preserved under opaque abstraction
   void visitTopLevelParams(AbstractionPattern origType,
                            CanAnyFunctionType::CanParamArrayRef params,
-                           SILExtInfoBuilder extInfoBuilder) {
+                           SILExtInfoBuilder extInfoBuilder,
+                           bool &unimplementable) {
     // If we're working with an opaque abstraction pattern, we never
     // have to worry about pack expansions, so we can go 1-1 with the
     // substituted parameters.
@@ -1569,6 +1571,31 @@ class DestructureInputs {
     origType.forEachFunctionParam(params.drop_back(hasSelf ? 1 : 0),
                                   /*ignore final orig param*/ hasSelf,
                                   [&](FunctionParamGenerator &param) {
+      // If the parameter is unimplementable because the orig function
+      // type is opaque and the next substituted param is a pack
+      // expansion, handle that first.
+      if (param.isUnimplementablePackExpansion()) {
+        // Record that we have an unimplementable parameter; this will
+        // ultimately end up in the function type, and then SILGen
+        // is supposed to diagnose any attempt to actually emit or
+        // call functions of such types.
+        unimplementable = true;
+
+        // Also, hack up a pack parameter defensively just in case we
+        // *do* try to actually use or emit a function with this type.
+        auto substParam = param.getSubstParams()[0];
+        auto loweredParamTy =
+          TC.getLoweredRValueType(expansion, param.getOrigType(),
+                                  substParam.getParameterType());
+        SILPackType::ExtInfo extInfo(/*address*/ true);
+        auto packTy = SILPackType::get(TC.Context, extInfo, {loweredParamTy});
+
+        auto origFlags = param.getOrigFlags();
+        addPackParameter(packTy, origFlags.getValueOwnership(),
+                         origFlags.isNoDerivative());
+        return;
+      }
+
       // If the parameter is not a pack expansion, just pull off the
       // next parameter and destructure it in parallel with the abstraction
       // pattern for the type.
@@ -2132,6 +2159,8 @@ static CanSILFunctionType getSILFunctionType(
   llvm::Optional<TypeConverter::GenericContextRAII> contextRAII;
   if (genericSig) contextRAII.emplace(TC, genericSig);
 
+  bool unimplementable = false;
+
   // Per above, only fully honor opaqueness in the abstraction pattern
   // for thick or polymorphic functions.  We don't need to worry about
   // non-opaque patterns because the type-checker forbids non-thick
@@ -2262,7 +2291,8 @@ static CanSILFunctionType getSILFunctionType(
     std::tie(origSubstPat, substFunctionTypeSubs, substYieldType)
       = origType.getSubstFunctionTypePattern(substFnInterfaceType, TC,
                                              coroutineOrigYieldType,
-                                             coroutineSubstYieldType);
+                                             coroutineSubstYieldType,
+                                             unimplementable);
 
     // We'll lower the abstraction pattern type against itself, and then apply
     // those substitutions to form the substituted lowered function type.
@@ -2289,7 +2319,7 @@ static CanSILFunctionType getSILFunctionType(
     DestructureInputs destructurer(expansionContext, TC, conventions,
                                    foreignInfo, inputs);
     destructurer.destructure(origType, substFnInterfaceType.getParams(),
-                             extInfoBuilder);
+                             extInfoBuilder, unimplementable);
   }
 
   // Destructure the coroutine yields.
@@ -2344,6 +2374,7 @@ static CanSILFunctionType getSILFunctionType(
                         .withIsPseudogeneric(pseudogeneric)
                         .withConcurrent(isSendable)
                         .withAsync(isAsync)
+                        .withUnimplementable(unimplementable)
                         .build();
 
   return SILFunctionType::get(genericSig, silExtInfo, coroutineKind,
@@ -2370,12 +2401,15 @@ static CanSILFunctionType getSILFunctionTypeForInitAccessor(
 
   // First compute `initialValue` input.
   {
+    bool unimplementable = false;
     ForeignInfo foreignInfo;
     DestructureInputs destructurer(context, TC, conventions, foreignInfo,
                                    inputs);
     destructurer.destructure(
         origType, substAccessorType.getParams(),
-        extInfoBuilder.withRepresentation(SILFunctionTypeRepresentation::Thin));
+        extInfoBuilder.withRepresentation(SILFunctionTypeRepresentation::Thin),
+        unimplementable);
+    assert(!unimplementable && "should never have an opaque AP here");
   }
 
   // Drop `self` parameter.