Merge branch 'main' of github.com:apple/swift into tensorflow-stage

* 'main' of github.com:apple/swift:
  [Concurrency] Include Task.sleep(until:) and Task.yield() placeholders
  [Concurrency] Task cancellation and deadline stubs
  [NameLookup] Retain invalid decls when filtering via access path
  [CodeCompletion] Do not include decl completion in its own initializer
  [cxx-interop] Fix infinite recursion of PackExpansion type.
  [Parse] Remove unused HandleCodeCompletion param in parseType()
  SILVerifier: async functions can be called from async functions only
  Revert change for storedDiagnosticInfos
  [CodeCompletion] Fix crashes in TypeCheckASTNodeAtLocRequest
  [CodeCompletion] Avoid prechecking twice when typeCheckForCodeCompletion is given a non-applicable expression (NFC)
  SILMem2Reg : Delete phi args added by Mem2Reg if there are no uses
  [ownership] Add a new ReborrowVerifier
  SIL: Look through SILBoxType when checking for invalid non-escaping function value captures
  [SR-13639][Diag] Don't diagnose local type declarations as unreachable
  Change macro to DIAG in storedDiagnosticInfos array
  Import Foundation in cxx interop tests that explicitly use/bridge its types
  [DiagnosticsQol] Modify diagnostic macro into single DIAG
  [Clang Importer] Do not rely on being able to always import Foundation on-demand When importing Clang types. This is not an option with Explicit Module Builds. If the module being built does not (directly or transitively) depend on `Foundation`, then attempting to load it will produce an error because Implicit module loading is no longer allowed..
  [Async CC] Auth'd parent context pointer.

Author: texasmichelle

include/swift/AST/IRGenOptions.h

@@ -137,6 +137,9 @@ struct PointerAuthOptions : clang::PointerAuthOptions {
 
   /// Resilient class stub initializer callbacks.
   PointerAuthSchema ResilientClassStubInitCallbacks;
+
+  /// The parent async context stored within a child async context.
+  PointerAuthSchema AsyncContextParent;
 };
 
 enum class JITDebugArtifact : unsigned {

include/swift/AST/Module.h

@@ -694,6 +694,9 @@ class ModuleDecl : public DeclContext, public TypeDecl {
   /// \returns true if this module is the "SwiftOnoneSupport" module;
   bool isOnoneSupportModule() const;
 
+  /// \returns true if this module is the "Foundation" module;
+  bool isFoundationModule() const;
+
   /// \returns true if traversal was aborted, false otherwise.
   bool walk(ASTWalker &Walker);
 

include/swift/AST/NameLookup.h

@@ -414,6 +414,22 @@ class AccessFilteringDeclConsumer final : public VisibleDeclConsumer {
                  DynamicLookupInfo dynamicLookupInfo = {}) override;
 };
 
+/// Filters out decls that are not usable based on their source location, eg.
+/// a decl inside its own initializer or a non-type decl before its definition.
+class UsableFilteringDeclConsumer final : public VisibleDeclConsumer {
+  const SourceManager &SM;
+  SourceLoc Loc;
+  VisibleDeclConsumer &ChainedConsumer;
+
+public:
+  UsableFilteringDeclConsumer(const SourceManager &SM, SourceLoc loc,
+                              VisibleDeclConsumer &consumer)
+      : SM(SM), Loc(loc), ChainedConsumer(consumer) {}
+
+  void foundDecl(ValueDecl *D, DeclVisibilityKind reason,
+                 DynamicLookupInfo dynamicLookupInfo) override;
+};
+
 /// Remove any declarations in the given set that were overridden by
 /// other declarations in that set.
 ///

include/swift/Parse/Parser.h

@@ -1176,15 +1176,12 @@ class Parser {
 
   ParserResult<TypeRepr> parseType();
   ParserResult<TypeRepr> parseType(Diag<> MessageID,
-                                   bool HandleCodeCompletion = true,
                                    bool IsSILFuncDecl = false);
 
   ParserResult<TypeRepr>
-    parseTypeSimpleOrComposition(Diag<> MessageID,
-                                 bool HandleCodeCompletion = true);
+    parseTypeSimpleOrComposition(Diag<> MessageID);
 
-  ParserResult<TypeRepr> parseTypeSimple(Diag<> MessageID,
-                                         bool HandleCodeCompletion = true);
+  ParserResult<TypeRepr> parseTypeSimple(Diag<> MessageID);
 
   /// Parse layout constraint.
   LayoutConstraint parseLayoutConstraint(Identifier LayoutConstraintID);

include/swift/SIL/LinearLifetimeChecker.h

@@ -50,6 +50,7 @@ class LinearLifetimeChecker {
   class ErrorBuilder;
 
 private:
+  friend class ReborrowVerifier;
   friend class SILOwnershipVerifier;
   friend class SILValueOwnershipChecker;
 

include/swift/SIL/OwnershipUtils.h

@@ -66,6 +66,9 @@ bool isOwnedForwardingInstruction(SILInstruction *inst);
 /// previous terminator.
 bool isOwnedForwardingValue(SILValue value);
 
+/// Returns true if the instruction is a 'reborrow'.
+bool isReborrowInstruction(const SILInstruction *inst);
+
 class BorrowingOperandKind {
 public:
   enum Kind : uint8_t {
@@ -134,7 +137,7 @@ struct BorrowingOperand {
     return BorrowingOperand(*kind, op);
   }
 
-  void visitEndScopeInstructions(function_ref<void(Operand *)> func) const;
+  void visitLocalEndScopeInstructions(function_ref<void(Operand *)> func) const;
 
   /// Returns true if this borrow scope operand consumes guaranteed
   /// values and produces a new scope afterwards.
@@ -204,7 +207,7 @@ struct BorrowingOperand {
   /// \p errorFunction a callback that if non-null is passed an operand that
   /// triggers a mal-formed SIL error. This is just needed for the ownership
   /// verifier to emit good output.
-  bool getImplicitUses(
+  void getImplicitUses(
       SmallVectorImpl<Operand *> &foundUses,
       std::function<void(Operand *)> *errorFunction = nullptr) const;
 

include/swift/SIL/SILValue.h

@@ -40,7 +40,8 @@ class SILInstruction;
 class SILLocation;
 class DeadEndBlocks;
 class ValueBaseUseIterator;
-class ValueUseIterator;
+class ConsumingUseIterator;
+class NonConsumingUseIterator;
 class SILValue;
 
 /// An enumeration which contains values for all the concrete ValueBase
@@ -263,10 +264,20 @@ class ValueBase : public SILNode, public SILAllocated<ValueBase> {
 
   using use_iterator = ValueBaseUseIterator;
   using use_range = iterator_range<use_iterator>;
+  using consuming_use_iterator = ConsumingUseIterator;
+  using consuming_use_range = iterator_range<consuming_use_iterator>;
+  using non_consuming_use_iterator = NonConsumingUseIterator;
+  using non_consuming_use_range = iterator_range<non_consuming_use_iterator>;
 
   inline use_iterator use_begin() const;
   inline use_iterator use_end() const;
 
+  inline consuming_use_iterator consuming_use_begin() const;
+  inline consuming_use_iterator consuming_use_end() const;
+
+  inline non_consuming_use_iterator non_consuming_use_begin() const;
+  inline non_consuming_use_iterator non_consuming_use_end() const;
+
   /// Returns a range of all uses, which is useful for iterating over all uses.
   /// To ignore debug-info instructions use swift::getNonDebugUses instead
   /// (see comment in DebugUtils.h).
@@ -285,6 +296,12 @@ class ValueBase : public SILNode, public SILAllocated<ValueBase> {
   /// and it has a single consuming user. Returns .none otherwise.
   inline Operand *getSingleConsumingUse() const;
 
+  /// Returns a range of all consuming uses
+  inline consuming_use_range getConsumingUses() const;
+
+  /// Returns a range of all non consuming uses
+  inline non_consuming_use_range getNonConsumingUses() const;
+
   template <class T>
   inline T *getSingleUserOfType() const;
 
@@ -711,8 +728,10 @@ class Operand {
     TheValue->FirstUse = this;
   }
 
+  friend class ValueBase;
   friend class ValueBaseUseIterator;
-  friend class ValueUseIterator;
+  friend class ConsumingUseIterator;
+  friend class NonConsumingUseIterator;
   template <unsigned N> friend class FixedOperandList;
   friend class TrailingOperandsList;
 };
@@ -729,6 +748,7 @@ using OperandValueArrayRef = ArrayRefView<Operand, SILValue, getSILValueType>;
 /// An iterator over all uses of a ValueBase.
 class ValueBaseUseIterator : public std::iterator<std::forward_iterator_tag,
                                                   Operand*, ptrdiff_t> {
+protected:
   Operand *Cur;
 public:
   ValueBaseUseIterator() = default;
@@ -770,6 +790,74 @@ inline ValueBase::use_iterator ValueBase::use_end() const {
 inline iterator_range<ValueBase::use_iterator> ValueBase::getUses() const {
   return { use_begin(), use_end() };
 }
+
+class ConsumingUseIterator : public ValueBaseUseIterator {
+public:
+  explicit ConsumingUseIterator(Operand *cur) : ValueBaseUseIterator(cur) {}
+  ConsumingUseIterator &operator++() {
+    assert(Cur && "incrementing past end()!");
+    assert(Cur->isConsumingUse());
+    while ((Cur = Cur->NextUse)) {
+      if (Cur->isConsumingUse())
+        break;
+    }
+    return *this;
+  }
+
+  ConsumingUseIterator operator++(int unused) {
+    ConsumingUseIterator copy = *this;
+    ++*this;
+    return copy;
+  }
+};
+
+inline ValueBase::consuming_use_iterator
+ValueBase::consuming_use_begin() const {
+  auto cur = FirstUse;
+  while (cur && !cur->isConsumingUse()) {
+    cur = cur->NextUse;
+  }
+  return ValueBase::consuming_use_iterator(cur);
+}
+
+inline ValueBase::consuming_use_iterator ValueBase::consuming_use_end() const {
+  return ValueBase::consuming_use_iterator(nullptr);
+}
+
+class NonConsumingUseIterator : public ValueBaseUseIterator {
+public:
+  explicit NonConsumingUseIterator(Operand *cur) : ValueBaseUseIterator(cur) {}
+  NonConsumingUseIterator &operator++() {
+    assert(Cur && "incrementing past end()!");
+    assert(!Cur->isConsumingUse());
+    while ((Cur = Cur->NextUse)) {
+      if (!Cur->isConsumingUse())
+        break;
+    }
+    return *this;
+  }
+
+  NonConsumingUseIterator operator++(int unused) {
+    NonConsumingUseIterator copy = *this;
+    ++*this;
+    return copy;
+  }
+};
+
+inline ValueBase::non_consuming_use_iterator
+ValueBase::non_consuming_use_begin() const {
+  auto cur = FirstUse;
+  while (cur && cur->isConsumingUse()) {
+    cur = cur->NextUse;
+  }
+  return ValueBase::non_consuming_use_iterator(cur);
+}
+
+inline ValueBase::non_consuming_use_iterator
+ValueBase::non_consuming_use_end() const {
+  return ValueBase::non_consuming_use_iterator(nullptr);
+}
+
 inline bool ValueBase::hasOneUse() const {
   auto I = use_begin(), E = use_end();
   if (I == E) return false;
@@ -806,6 +894,15 @@ inline Operand *ValueBase::getSingleConsumingUse() const {
   return result;
 }
 
+inline ValueBase::consuming_use_range ValueBase::getConsumingUses() const {
+  return {consuming_use_begin(), consuming_use_end()};
+}
+
+inline ValueBase::non_consuming_use_range
+ValueBase::getNonConsumingUses() const {
+  return {non_consuming_use_begin(), non_consuming_use_end()};
+}
+
 inline bool ValueBase::hasTwoUses() const {
   auto iter = use_begin(), end = use_end();
   for (unsigned i = 0; i < 2; ++i) {

lib/AST/DiagnosticEngine.cpp

@@ -93,19 +93,13 @@ static_assert(sizeof(storedDiagnosticInfos) / sizeof(StoredDiagnosticInfo) ==
               "array size mismatch");
 
 static constexpr const char * const diagnosticStrings[] = {
-#define ERROR(ID, Options, Text, Signature) Text,
-#define WARNING(ID, Options, Text, Signature) Text,
-#define NOTE(ID, Options, Text, Signature) Text,
-#define REMARK(ID, Options, Text, Signature) Text,
+#define DIAG(KIND, ID, Options, Text, Signature) Text,
 #include "swift/AST/DiagnosticsAll.def"
     "<not a diagnostic>",
 };
 
 static constexpr const char *const debugDiagnosticStrings[] = {
-#define ERROR(ID, Options, Text, Signature) Text " [" #ID "]",
-#define WARNING(ID, Options, Text, Signature) Text " [" #ID "]",
-#define NOTE(ID, Options, Text, Signature) Text " [" #ID "]",
-#define REMARK(ID, Options, Text, Signature) Text " [" #ID "]",
+#define DIAG(KIND, ID, Options, Text, Signature) Text " [" #ID "]",
 #include "swift/AST/DiagnosticsAll.def"
     "<not a diagnostic>",
 };

lib/AST/Module.cpp

@@ -1336,6 +1336,10 @@ bool ModuleDecl::isOnoneSupportModule() const {
   return !getParent() && getName().str() == SWIFT_ONONE_SUPPORT;
 }
 
+bool ModuleDecl::isFoundationModule() const {
+  return !getParent() && getName() == getASTContext().Id_Foundation;
+}
+
 bool ModuleDecl::isBuiltinModule() const {
   return this == getASTContext().TheBuiltinModule;
 }

lib/AST/NameLookup.cpp

@@ -138,14 +138,40 @@ void DebuggerClient::anchor() {}
 void AccessFilteringDeclConsumer::foundDecl(
     ValueDecl *D, DeclVisibilityKind reason,
     DynamicLookupInfo dynamicLookupInfo) {
-  if (D->hasInterfaceType() && D->isInvalid())
-    return;
   if (!D->isAccessibleFrom(DC))
     return;
 
   ChainedConsumer.foundDecl(D, reason, dynamicLookupInfo);
 }
 
+void UsableFilteringDeclConsumer::foundDecl(ValueDecl *D,
+    DeclVisibilityKind reason, DynamicLookupInfo dynamicLookupInfo) {
+  // Skip when Loc is within the decl's own initializer
+  if (auto *VD = dyn_cast<VarDecl>(D)) {
+    if (auto *init = VD->getParentInitializer()) {
+      auto initRange = init->getSourceRange();
+      if (initRange.isValid() && SM.rangeContainsTokenLoc(initRange, Loc))
+        return;
+    }
+  }
+
+  switch (reason) {
+  case DeclVisibilityKind::LocalVariable:
+    // Skip if Loc is before the found decl, unless its a TypeDecl (whose use
+    // before its declaration is still allowed)
+    if (!isa<TypeDecl>(D) && !SM.isBeforeInBuffer(D->getLoc(), Loc))
+      return;
+    break;
+  default:
+    // The rest of the file is currently skipped, so no need to check
+    // decl location for VisibleAtTopLevel. Other visibility kinds are always
+    // usable
+    break;
+  }
+
+  ChainedConsumer.foundDecl(D, reason, dynamicLookupInfo);
+}
+
 void LookupResultEntry::print(llvm::raw_ostream& out) const {
   getValueDecl()->print(out);
   if (auto dc = getBaseDecl()) {

lib/ClangImporter/ImportDecl.cpp

@@ -5696,8 +5696,7 @@ namespace {
 }
 
 static bool conformsToProtocolInOriginalModule(NominalTypeDecl *nominal,
-                                               const ProtocolDecl *proto,
-                                               ModuleDecl *foundationModule) {
+                                               const ProtocolDecl *proto) {
   auto &ctx = nominal->getASTContext();
 
   if (inheritanceListContainsProtocol(nominal, proto))
@@ -5720,7 +5719,7 @@ static bool conformsToProtocolInOriginalModule(NominalTypeDecl *nominal,
   for (ExtensionDecl *extension : nominal->getExtensions()) {
     ModuleDecl *extensionModule = extension->getParentModule();
     if (extensionModule != originalModule && extensionModule != overlayModule &&
-        extensionModule != foundationModule) {
+        !extensionModule->isFoundationModule()) {
       continue;
     }
     if (inheritanceListContainsProtocol(extension, proto))
@@ -5815,8 +5814,7 @@ SwiftDeclConverter::importSwiftNewtype(const clang::TypedefNameDecl *decl,
 
     // Break circularity by only looking for declared conformances in the
     // original module, or possibly its overlay.
-    if (conformsToProtocolInOriginalModule(computedNominal, proto,
-                                           Impl.tryLoadFoundationModule())) {
+    if (conformsToProtocolInOriginalModule(computedNominal, proto)) {
       synthesizedProtocols.push_back(kind);
       return true;
     }