Merge pull request #2948 from swiftwasm/katei/merge-main-2021-04-08

Merge main 2021-04-08

Author: MaxDesiatov

docs/ABI/Mangling.rst

@@ -147,7 +147,6 @@ Globals
   // TODO check this::
   global ::= mangled-name 'TA'                     // partial application forwarder
   global ::= mangled-name 'Ta'                     // ObjC partial application forwarder
-  global ::= mangled-name 'Tw' index               // async partial apply thunk for a non-constant function
   global ::= mangled-name 'TQ' index               // Async await continuation partial function
   global ::= mangled-name 'TY' index               // Async suspend continuation partial function
 

docs/Testing.md

@@ -124,7 +124,9 @@ out with ``lit.py -h``. We document some of the more useful ones below:
          line, amid a sequence.
 * ``-a`` causes a test's commandline and output to always be printed.
 * ``--filter=<pattern>`` causes only tests with paths matching the given regular
-  expression to be run.
+  expression to be run. Alternately, you can use the `LIT_FILTER='<pattern>'`
+  environment variable, in case you're invoking `lit.py` through some other
+  tool such as `build-script`.
 * ``-i`` causes tests that have a newer modification date and failing tests to
   be run first. This is implemented by updating the mtimes of the tests.
 * ``--no-execute`` causes a dry run to be performed. *NOTE* This means that all

include/swift/AST/ASTDemangler.h

@@ -59,8 +59,6 @@ class ASTBuilder {
   using BuiltType = swift::Type;
   using BuiltTypeDecl = swift::GenericTypeDecl *; // nominal or type alias
   using BuiltProtocolDecl = swift::ProtocolDecl *;
-  using BuiltSubstitution = std::pair<Type, Type>;
-  using BuiltRequirement = swift::Requirement;
   explicit ASTBuilder(ASTContext &ctx) : Ctx(ctx) {}
 
   ASTContext &getASTContext() { return Ctx; }
@@ -103,14 +101,11 @@ class ASTBuilder {
       FunctionMetadataDifferentiabilityKind diffKind);
 
   Type createImplFunctionType(
-      Demangle::ImplParameterConvention calleeConvention,
-      BuiltRequirement *witnessMethodConformanceRequirement,
-      ArrayRef<BuiltType> GenericParameters,
-      ArrayRef<BuiltRequirement> Requirements,
-      ArrayRef<Demangle::ImplFunctionParam<Type>> params,
-      ArrayRef<Demangle::ImplFunctionResult<Type>> results,
-      Optional<Demangle::ImplFunctionResult<Type>> errorResult,
-      ImplFunctionTypeFlags flags);
+    Demangle::ImplParameterConvention calleeConvention,
+    ArrayRef<Demangle::ImplFunctionParam<Type>> params,
+    ArrayRef<Demangle::ImplFunctionResult<Type>> results,
+    Optional<Demangle::ImplFunctionResult<Type>> errorResult,
+    ImplFunctionTypeFlags flags);
 
   Type createProtocolCompositionType(ArrayRef<ProtocolDecl *> protocols,
                                      Type superclass,
@@ -135,6 +130,8 @@ class ASTBuilder {
 
   Type createSILBoxType(Type base);
   using BuiltSILBoxField = llvm::PointerIntPair<Type, 1>;
+  using BuiltSubstitution = std::pair<Type, Type>;
+  using BuiltRequirement = swift::Requirement;
   using BuiltLayoutConstraint = swift::LayoutConstraint;
   Type createSILBoxTypeWithLayout(ArrayRef<BuiltSILBoxField> Fields,
                                   ArrayRef<BuiltSubstitution> Substitutions,

include/swift/AST/ASTScope.h

@@ -703,7 +703,7 @@ class OpaqueTypeScope final : public GenericTypeScope {
   Decl *getDecl() const override { return decl; }
 };
 
-/// Since each generic parameter can "see" the preceeding ones,
+/// Since each generic parameter can "see" the preceding ones,
 /// (e.g. <A, B: A>) -- it's not legal but that's how lookup behaves --
 /// Each GenericParamScope scopes just ONE parameter, and we next
 /// each one within the previous one.

include/swift/AST/Decl.h

@@ -789,6 +789,9 @@ class alignas(1 << DeclAlignInBits) Decl {
     return Attrs;
   }
 
+  /// Returns the innermost enclosing decl with an availability annotation.
+  const Decl *getInnermostDeclWithAvailability() const;
+
   /// Returns the introduced OS version in the given platform kind specified
   /// by @available attribute.
   /// This function won't consider the parent context to get the information.

include/swift/AST/IRGenOptions.h

@@ -142,6 +142,26 @@ struct PointerAuthOptions : clang::PointerAuthOptions {
   /// Resilient class stub initializer callbacks.
   PointerAuthSchema ResilientClassStubInitCallbacks;
 
+  /// Like SwiftFunctionPointers but for use with AsyncFunctionPointer values.
+  PointerAuthSchema AsyncSwiftFunctionPointers;
+
+  /// Like SwiftClassMethods but for use with AsyncFunctionPointer values.
+  PointerAuthSchema AsyncSwiftClassMethods;
+
+  /// Like ProtocolWitnesses but for use with AsyncFunctionPointer values.
+  PointerAuthSchema AsyncProtocolWitnesses;
+
+  /// Like SwiftClassMethodPointers but for use with AsyncFunctionPointer
+  /// values.
+  PointerAuthSchema AsyncSwiftClassMethodPointers;
+
+  /// Like SwiftDynamicReplacements but for use with AsyncFunctionPointer
+  /// values.
+  PointerAuthSchema AsyncSwiftDynamicReplacements;
+
+  /// Like PartialApplyCapture but for use with AsyncFunctionPointer values.
+  PointerAuthSchema AsyncPartialApplyCapture;
+
   /// The parent async context stored within a child async context.
   PointerAuthSchema AsyncContextParent;
 

include/swift/AST/PrintOptions.h

@@ -371,6 +371,12 @@ struct PrintOptions {
   /// Whether to print the extensions from conforming protocols.
   bool PrintExtensionFromConformingProtocols = false;
 
+  /// Whether to always try and print parameter labels. If present, print the
+  /// external parameter name. Otherwise try printing the internal name as
+  /// `_ <internalName>`, if an internal name exists. If neither an external nor
+  /// an internal name exists, only print the parameter's type.
+  bool AlwaysTryPrintParameterLabels = false;
+
   std::shared_ptr<ShouldPrintChecker> CurrentPrintabilityChecker =
     std::make_shared<ShouldPrintChecker>();
 

include/swift/AST/Types.h

@@ -2785,8 +2785,9 @@ class AnyFunctionType : public TypeBase {
   public:
     explicit Param(Type t,
                    Identifier l = Identifier(),
-                   ParameterTypeFlags f = ParameterTypeFlags())
-        : Ty(t), Label(l), Flags(f) {
+                   ParameterTypeFlags f = ParameterTypeFlags(),
+                   Identifier internalLabel = Identifier())
+        : Ty(t), Label(l), InternalLabel(internalLabel), Flags(f) {
       assert(t && "param type must be non-null");
       assert(!t->is<InOutType>() && "set flags instead");
     }
@@ -2796,8 +2797,18 @@ class AnyFunctionType : public TypeBase {
     /// element type.
     Type Ty;
 
-    // The label associated with the parameter, if any.
+    /// The label associated with the parameter, if any.
     Identifier Label;
+
+    /// The internal label of the parameter, if explicitly specified, otherwise
+    /// empty. The internal label is considered syntactic sugar. It is not
+    /// considered part of the canonical type and is thus also ignored in \c
+    /// operator==.
+    /// E.g.
+    ///  - `name name2: Int` has internal label `name2`
+    ///  - `_ name2: Int` has internal label `name2`
+    ///  - `name: Int` has no internal label
+    Identifier InternalLabel;
 
     /// Parameter specific flags.
     ParameterTypeFlags Flags = {};
@@ -2823,6 +2834,9 @@ class AnyFunctionType : public TypeBase {
 
     bool hasLabel() const { return !Label.empty(); }
     Identifier getLabel() const { return Label; }
+
+    bool hasInternalLabel() const { return !InternalLabel.empty(); }
+    Identifier getInternalLabel() const { return InternalLabel; }
 
     ParameterTypeFlags getParameterFlags() const { return Flags; }
 
@@ -2851,23 +2865,34 @@ class AnyFunctionType : public TypeBase {
       return Flags.getValueOwnership();
     }
 
+    /// Returns \c true if the two \c Params are equal in their canonicalized
+    /// form.
+    /// Two \c Params are equal if their external label, flags and
+    /// *canonicalized* types match. The internal label and sugar types are
+    /// *not* considered for type equality.
     bool operator==(Param const &b) const {
       return (Label == b.Label &&
               getPlainType()->isEqual(b.getPlainType()) &&
               Flags == b.Flags);
     }
     bool operator!=(Param const &b) const { return !(*this == b); }
 
-    Param getWithoutLabel() const { return Param(Ty, Identifier(), Flags); }
+    /// Return the parameter without external and internal labels.
+    Param getWithoutLabels() const {
+      return Param(Ty, /*Label=*/Identifier(), Flags,
+                   /*InternalLabel=*/Identifier());
+    }
 
     Param withLabel(Identifier newLabel) const {
-      return Param(Ty, newLabel, Flags);
+      return Param(Ty, newLabel, Flags, InternalLabel);
     }
 
-    Param withType(Type newType) const { return Param(newType, Label, Flags); }
+    Param withType(Type newType) const {
+      return Param(newType, Label, Flags, InternalLabel);
+    }
 
     Param withFlags(ParameterTypeFlags flags) const {
-      return Param(Ty, Label, flags);
+      return Param(Ty, Label, flags, InternalLabel);
     }
   };
 
@@ -2988,14 +3013,19 @@ class AnyFunctionType : public TypeBase {
     return composeInput(ctx, params.getOriginalArray(), canonicalVararg);
   }
 
-  /// Given two arrays of parameters determine if they are equal.
+  /// Given two arrays of parameters determine if they are equal in their
+  /// canonicalized form. Internal labels and type sugar is *not* taken into
+  /// account.
   static bool equalParams(ArrayRef<Param> a, ArrayRef<Param> b);
 
-  /// Given two arrays of parameters determine if they are equal.
+  /// Given two arrays of parameters determine if they are equal in their
+  /// canonicalized form. Internal labels and type sugar is *not* taken into
+  /// account.
   static bool equalParams(CanParamArrayRef a, CanParamArrayRef b);
 
   /// Given an array of parameters and an array of labels of the
   /// same length, update each parameter to have the corresponding label.
+  /// The internal parameter labels remain the same.
   static void relabelParams(MutableArrayRef<Param> params,
                             ArrayRef<Identifier> labels);
 

include/swift/Demangling/DemangleNodes.def

@@ -313,7 +313,6 @@ NODE(AutoDiffSubsetParametersThunk)
 NODE(AutoDiffDerivativeVTableThunk)
 NODE(DifferentiabilityWitness)
 NODE(IndexSubset)
-NODE(AsyncNonconstantPartialApplyThunk)
 NODE(AsyncAwaitResumePartialFunction)
 NODE(AsyncSuspendResumePartialFunction)
 

include/swift/Demangling/TypeDecoder.h

@@ -814,12 +814,9 @@ class TypeDecoder {
     }
     case NodeKind::ImplFunctionType: {
       auto calleeConvention = ImplParameterConvention::Direct_Unowned;
-      BuiltRequirement *witnessMethodConformanceRequirement = nullptr;
       llvm::SmallVector<ImplFunctionParam<BuiltType>, 8> parameters;
       llvm::SmallVector<ImplFunctionResult<BuiltType>, 8> results;
       llvm::SmallVector<ImplFunctionResult<BuiltType>, 8> errorResults;
-      llvm::SmallVector<BuiltType, 4> genericParameters;
-      llvm::SmallVector<BuiltRequirement, 4> requirements;
       ImplFunctionTypeFlags flags;
 
       for (unsigned i = 0; i < Node->getNumChildren(); i++) {
@@ -852,9 +849,6 @@ class TypeDecoder {
           } else if (text == "block") {
             flags =
               flags.withRepresentation(ImplFunctionRepresentation::Block);
-          } else if (text == "witness_method") {
-            flags = flags.withRepresentation(
-                ImplFunctionRepresentation::WitnessMethod);
           }
         } else if (child->getKind() == NodeKind::ImplFunctionAttribute) {
           if (!child->hasText())
@@ -892,27 +886,6 @@ class TypeDecoder {
           if (decodeImplFunctionPart(child, errorResults))
             return MAKE_NODE_TYPE_ERROR0(child,
                                          "failed to decode function part");
-        } else if (child->getKind() == NodeKind::DependentGenericSignature) {
-          llvm::SmallVector<unsigned, 4> genericParamsAtDepth;
-
-          if (auto error = decodeDependentGenericSignatureNode(
-                  child, requirements, genericParamsAtDepth))
-            return *error;
-          if (flags.getRepresentation() ==
-              ImplFunctionRepresentation::WitnessMethod) {
-            // By convention, the first requirement of a witness method is the
-            // conformance of Self to the protocol.
-            witnessMethodConformanceRequirement = &requirements[0];
-          }
-
-          for (unsigned long depth = 0, depths = genericParamsAtDepth.size();
-               depth < depths; ++depth) {
-            for (unsigned index = 0; index < genericParamsAtDepth[depth];
-                 ++index) {
-              genericParameters.emplace_back(
-                  Builder.createGenericTypeParameterType(depth, index));
-            }
-          }
         } else {
           return MAKE_NODE_TYPE_ERROR0(child, "unexpected kind");
         }
@@ -933,11 +906,11 @@ class TypeDecoder {
       // TODO: Some cases not handled above, but *probably* they cannot
       // appear as the types of values in SIL (yet?):
       // - functions with yield returns
+      // - functions with generic signatures
       // - foreign error conventions
-      return Builder.createImplFunctionType(
-          calleeConvention, witnessMethodConformanceRequirement,
-          genericParameters, requirements, parameters, results, errorResult,
-          flags);
+      return Builder.createImplFunctionType(calleeConvention,
+                                            parameters, results,
+                                            errorResult, flags);
     }
 
     case NodeKind::ArgumentTuple:
@@ -1108,12 +1081,35 @@ class TypeDecoder {
           return MAKE_NODE_TYPE_ERROR0(substNode, "expected type list");
 
         auto *dependentGenericSignatureNode = Node->getChild(1);
+        if (dependentGenericSignatureNode->getKind() !=
+            NodeKind::DependentGenericSignature)
+          return MAKE_NODE_TYPE_ERROR0(dependentGenericSignatureNode,
+                                       "expected dependent generic signature");
+        if (dependentGenericSignatureNode->getNumChildren() < 1)
+          return MAKE_NODE_TYPE_ERROR(
+              dependentGenericSignatureNode,
+              "fewer children (%zu) than required (1)",
+              dependentGenericSignatureNode->getNumChildren());
+        decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,
+                          BuilderType>(
+            dependentGenericSignatureNode, requirements, Builder/*,
+            [&](NodePointer Node) -> BuiltType {
+              return decodeMangledType(Node).getType();
+            },
+            [&](LayoutConstraintKind Kind) -> BuiltLayoutConstraint {
+              return {}; // Not implemented!
+            },
+            [&](LayoutConstraintKind Kind, unsigned SizeInBits,
+                unsigned Alignment) -> BuiltLayoutConstraint {
+              return {}; // Not Implemented!
+              }*/);
+        // The number of generic parameters at each depth are in a mini
+        // state machine and come first.
         llvm::SmallVector<unsigned, 4> genericParamsAtDepth;
-        if (auto error = decodeDependentGenericSignatureNode(
-                dependentGenericSignatureNode, requirements,
-                genericParamsAtDepth))
-          return *error;
-
+        for (auto *reqNode : *dependentGenericSignatureNode)
+          if (reqNode->getKind() == NodeKind::DependentGenericParamCount)
+            if (reqNode->hasIndex())
+              genericParamsAtDepth.push_back(reqNode->getIndex());
         unsigned depth = 0;
         unsigned index = 0;
         for (auto *subst : *substNode) {
@@ -1463,43 +1459,6 @@ class TypeDecoder {
     params.push_back(std::move(param));
     return true;
   }
-
-  llvm::Optional<TypeLookupError> decodeDependentGenericSignatureNode(
-      NodePointer dependentGenericSignatureNode,
-      llvm::SmallVectorImpl<BuiltRequirement> &requirements,
-      llvm::SmallVectorImpl<unsigned> &genericParamsAtDepth) {
-    using NodeKind = Demangle::Node::Kind;
-    if (dependentGenericSignatureNode->getKind() !=
-        NodeKind::DependentGenericSignature)
-      return llvm::Optional<TypeLookupError>(
-          MAKE_NODE_TYPE_ERROR0(dependentGenericSignatureNode,
-                                "expected dependent generic signature"));
-    if (dependentGenericSignatureNode->getNumChildren() < 1)
-      return llvm::Optional<TypeLookupError>(MAKE_NODE_TYPE_ERROR(
-          dependentGenericSignatureNode,
-          "fewer children (%zu) than required (1)",
-          dependentGenericSignatureNode->getNumChildren()));
-    decodeRequirement<BuiltType, BuiltRequirement, BuiltLayoutConstraint,
-                      BuilderType>(dependentGenericSignatureNode, requirements,
-                                   Builder /*,
-[&](NodePointer Node) -> BuiltType {
-return decodeMangledType(Node).getType();
-},
-[&](LayoutConstraintKind Kind) -> BuiltLayoutConstraint {
-return {}; // Not implemented!
-},
-[&](LayoutConstraintKind Kind, unsigned SizeInBits,
-unsigned Alignment) -> BuiltLayoutConstraint {
-return {}; // Not Implemented!
-}*/);
-    // The number of generic parameters at each depth are in a mini
-    // state machine and come first.
-    for (auto *reqNode : *dependentGenericSignatureNode)
-      if (reqNode->getKind() == NodeKind::DependentGenericParamCount)
-        if (reqNode->hasIndex())
-          genericParamsAtDepth.push_back(reqNode->getIndex());
-    return llvm::None;
-  }
 };
 
 template <typename BuilderType>