Merge pull request #3972 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

docs/DifferentiableProgramming.md

@@ -698,7 +698,7 @@ differentiation: given an "original function" to differentiate, a derivative
 function is generated by replacing function applications in the original
 function with corresponding derivative function applications. The algorithm is
 described in detail in the
-[Swift Differentiable Programming Implementation Overview document](http://bit.ly/swift-autodiff-internals).
+[Swift Differentiable Programming Implementation Overview](DifferentiableProgrammingImplementation.md).
 
 Some languages provide the ability to define custom code transformations:
 

docs/DifferentiableProgrammingImplementation.md

@@ -1231,6 +1231,11 @@ class ASTContext final {
   bool isRecursivelyConstructingRequirementMachine(
       CanGenericSignature sig);
 
+  /// This is a hack to break cycles. Don't introduce new callers of this
+  /// method.
+  bool isRecursivelyConstructingRequirementMachine(
+      const ProtocolDecl *proto);
+
   /// Retrieve a generic signature with a single unconstrained type parameter,
   /// like `<T>`.
   CanGenericSignature getSingleGenericParameterSignature() const;

docs/assets/DifferentiableProgrammingImplementation/differentiation-control-flow.png

@@ -699,7 +699,7 @@ CONTEXTUAL_SIMPLE_DECL_ATTR(_const, CompileTimeConst,
   ABIStableToAdd | ABIStableToRemove | APIBreakingToAdd | APIStableToRemove,
   126)
 
-SIMPLE_DECL_ATTR(_unavailableFromAsync, UnavailableFromAsync,
+DECL_ATTR(_unavailableFromAsync, UnavailableFromAsync,
   OnFunc | OnConstructor | UserInaccessible |
   ABIStableToAdd | ABIStableToRemove |
   APIBreakingToAdd | APIStableToRemove,

docs/assets/DifferentiableProgrammingImplementation/swift-compilation-pipeline.png

@@ -2085,6 +2085,26 @@ class TypeSequenceAttr : public DeclAttribute {
   }
 };
 
+/// The @_unavailableFromAsync attribute, used to make function declarations
+/// unavailable from async contexts.
+class UnavailableFromAsyncAttr : public DeclAttribute {
+public:
+  UnavailableFromAsyncAttr(StringRef Message, SourceLoc AtLoc,
+                           SourceRange Range, bool Implicit)
+      : DeclAttribute(DAK_UnavailableFromAsync, AtLoc, Range, Implicit),
+        Message(Message) {}
+  UnavailableFromAsyncAttr(StringRef Message, bool Implicit)
+      : UnavailableFromAsyncAttr(Message, SourceLoc(), SourceRange(),
+                                 Implicit) {}
+  const StringRef Message;
+
+  bool hasMessage() const { return !Message.empty(); }
+
+  static bool classof(const DeclAttribute *DA) {
+    return DA->getKind() == DAK_UnavailableFromAsync;
+  }
+};
+
 /// Attributes that may be applied to declarations.
 class DeclAttributes {
   /// Linked list of declaration attributes.

include/swift/AST/ASTContext.h

@@ -1435,6 +1435,8 @@ ERROR(attr_missing_label,PointsToFirstBadToken,
       "missing label '%0:' in '@%1' attribute", (StringRef, StringRef))
 ERROR(attr_expected_label,none,
       "expected label '%0:' in '@%1' attribute", (StringRef, StringRef))
+ERROR(attr_expected_colon_after_label,none,
+      "expected ':' after label '%0'", (StringRef))
 
 ERROR(alignment_must_be_positive_integer,none,
       "alignment value must be a positive integer literal", ())

include/swift/AST/Attr.def

@@ -4719,7 +4719,8 @@ ERROR(async_named_decl_must_be_available_from_async,none,
         "asynchronous %0 %1 must be available from asynchronous contexts",
         (DescriptiveDeclKind, DeclName))
 ERROR(async_unavailable_decl,none,
-      "%0 %1 is unavailable from asynchronous contexts", (DescriptiveDeclKind, DeclBaseName))
+      "%0 %1 is unavailable from asynchronous contexts%select{|; %3}2",
+      (DescriptiveDeclKind, DeclBaseName, bool, StringRef))
 
 //------------------------------------------------------------------------------
 // MARK: Type Check Types

include/swift/AST/Attr.h

@@ -2017,6 +2017,11 @@ bool ASTContext::isRecursivelyConstructingRequirementMachine(
   return getRewriteContext().isRecursivelyConstructingRequirementMachine(sig);
 }
 
+bool ASTContext::isRecursivelyConstructingRequirementMachine(
+      const ProtocolDecl *proto) {
+  return getRewriteContext().isRecursivelyConstructingRequirementMachine(proto);
+}
+
 Optional<llvm::TinyPtrVector<ValueDecl *>>
 OverriddenDeclsRequest::getCachedResult() const {
   auto decl = std::get<0>(getStorage());

include/swift/AST/DiagnosticsParse.def

@@ -1164,6 +1164,17 @@ bool DeclAttribute::printImpl(ASTPrinter &Printer, const PrintOptions &Options,
     break;
   }
 
+  case DAK_UnavailableFromAsync: {
+    Printer.printAttrName("@_unavailableFromAsync");
+    const UnavailableFromAsyncAttr *attr = cast<UnavailableFromAsyncAttr>(this);
+    if (attr->hasMessage()) {
+      Printer << "(message: \"";
+      Printer << attr->Message;
+      Printer << "\")";
+    }
+    break;
+  }
+
   case DAK_Count:
     llvm_unreachable("exceed declaration attribute kinds");
 
@@ -1317,6 +1328,8 @@ StringRef DeclAttribute::getAttrName() const {
     return "transpose";
   case DAK_TypeSequence:
     return "_typeSequence";
+  case DAK_UnavailableFromAsync:
+    return "_unavailableFromAsync";
   }
   llvm_unreachable("bad DeclAttrKind");
 }

include/swift/AST/DiagnosticsSema.def

@@ -680,6 +680,9 @@ struct GenericSignatureBuilder::Implementation {
   /// requirements.
   bool RebuildingWithoutRedundantConformances = false;
 
+  /// Whether we are building a protocol requirement signature.
+  bool BuildingProtocolRequirementSignature = false;
+
   /// A mapping of redundant explicit requirements to the best root requirement
   /// that implies them. Built by computeRedundantRequirements().
   using RedundantRequirementMap =
@@ -2313,6 +2316,11 @@ void GenericSignatureBuilder::addConditionalRequirements(
   if (Impl->RebuildingWithoutRedundantConformances)
     return;
 
+  // We do not perform requirement inference, including conditional requirement
+  // inference, inside protocols.
+  if (Impl->BuildingProtocolRequirementSignature)
+    return;
+
   // Abstract conformances don't have associated decl-contexts/modules, but also
   // don't have conditional requirements.
   if (conformance.isConcrete()) {
@@ -3399,10 +3407,12 @@ void EquivalenceClass::modified(GenericSignatureBuilder &builder) {
 }
 
 GenericSignatureBuilder::GenericSignatureBuilder(
-                               ASTContext &ctx)
+                               ASTContext &ctx,
+                               bool requirementSignature)
   : Context(ctx), Diags(Context.Diags), Impl(new Implementation) {
   if (auto *Stats = Context.Stats)
     ++Stats->getFrontendCounters().NumGenericSignatureBuilders;
+  Impl->BuildingProtocolRequirementSignature = requirementSignature;
 }
 
 GenericSignatureBuilder::GenericSignatureBuilder(
@@ -3991,6 +4001,8 @@ ConstraintResult GenericSignatureBuilder::expandConformanceRequirement(
   auto protocolSubMap = SubstitutionMap::getProtocolSubstitutions(
       proto, selfType.getDependentType(*this), ProtocolConformanceRef(proto));
 
+  auto result = ConstraintResult::Resolved;
+
   // Use the requirement signature to avoid rewalking the entire protocol.  This
   // cannot compute the requirement signature directly, because that may be
   // infinitely recursive: this code is also used to construct it.
@@ -4007,19 +4019,20 @@ ConstraintResult GenericSignatureBuilder::expandConformanceRequirement(
       auto reqResult = substReq
                            ? addRequirement(*substReq, innerSource, nullptr)
                            : ConstraintResult::Conflicting;
-      if (isErrorResult(reqResult)) return reqResult;
+      if (isErrorResult(reqResult) && !isErrorResult(result))
+        result = reqResult;
     }
 
-    return ConstraintResult::Resolved;
+    return result;
   }
 
   if (!onlySameTypeConstraints) {
     // Add all of the inherited protocol requirements, recursively.
     auto inheritedReqResult =
       addInheritedRequirements(proto, selfType.getUnresolvedType(), source,
                                nullptr);
-    if (isErrorResult(inheritedReqResult))
-      return inheritedReqResult;
+    if (isErrorResult(inheritedReqResult) && !isErrorResult(inheritedReqResult))
+      result = inheritedReqResult;
   }
 
   // Add any requirements in the where clause on the protocol.
@@ -4048,7 +4061,7 @@ ConstraintResult GenericSignatureBuilder::expandConformanceRequirement(
                              getASTContext()),
                          innerSource);
 
-    return ConstraintResult::Resolved;
+    return result;
   }
 
   // Remaining logic is not relevant in ObjC protocol cases.
@@ -4156,11 +4169,13 @@ ConstraintResult GenericSignatureBuilder::expandConformanceRequirement(
     Type assocType =
       DependentMemberType::get(selfType.getDependentType(*this), assocTypeDecl);
     if (!onlySameTypeConstraints) {
+      (void) resolve(assocType, source);
+
       auto assocResult =
         addInheritedRequirements(assocTypeDecl, assocType, source,
                                  /*inferForModule=*/nullptr);
-      if (isErrorResult(assocResult))
-        return assocResult;
+      if (isErrorResult(assocResult) && !isErrorResult(result))
+        result = assocResult;
     }
 
     // Add requirements from this associated type's where clause.
@@ -4314,7 +4329,7 @@ ConstraintResult GenericSignatureBuilder::expandConformanceRequirement(
     }
   }
 
-  return ConstraintResult::Resolved;
+  return result;
 }
 
 ConstraintResult GenericSignatureBuilder::addConformanceRequirement(
@@ -8830,7 +8845,8 @@ RequirementSignatureRequest::evaluate(Evaluator &evaluator,
   }
 
   auto buildViaGSB = [&]() {
-    GenericSignatureBuilder builder(proto->getASTContext());
+    GenericSignatureBuilder builder(proto->getASTContext(),
+                                    /*requirementSignature=*/true);
 
     // Add all of the generic parameters.
     for (auto gp : *proto->getGenericParams())
@@ -8873,9 +8889,23 @@ RequirementSignatureRequest::evaluate(Evaluator &evaluator,
     auto rqmResult = buildViaRQM();
     auto gsbResult = buildViaGSB();
 
-    if (rqmResult.size() != gsbResult.size() ||
-        !std::equal(rqmResult.begin(), rqmResult.end(),
-                    gsbResult.begin())) {
+    // For now, only compare conformance requirements, since those are the
+    // important ones from the ABI perspective.
+    SmallVector<Requirement, 2> rqmConformances;
+    for (auto req : rqmResult) {
+      if (req.getKind() == RequirementKind::Conformance)
+        rqmConformances.push_back(req);
+    }
+    SmallVector<Requirement, 2> gsbConformances;
+    for (auto req : gsbResult) {
+      if (req.getKind() == RequirementKind::Conformance)
+        gsbConformances.push_back(req);
+    }
+
+    if (rqmConformances.size() != gsbConformances.size() ||
+        !std::equal(rqmConformances.begin(),
+                    rqmConformances.end(),
+                    gsbConformances.begin())) {
       llvm::errs() << "RequirementMachine protocol signature minimization is broken:\n";
       llvm::errs() << "Protocol: " << proto->getName() << "\n";
 

lib/AST/ASTContext.cpp

@@ -496,7 +496,8 @@ class GenericSignatureBuilder {
 
 public:
   /// Construct a new generic signature builder.
-  explicit GenericSignatureBuilder(ASTContext &ctx);
+  explicit GenericSignatureBuilder(ASTContext &ctx,
+                                   bool requirementSignature=false);
   GenericSignatureBuilder(GenericSignatureBuilder &&);
   ~GenericSignatureBuilder();