[TypeChecker] Make sure that @preconcurrency use is detected in base expressions

This expands #77510 to base
expressions of calls, subscripts and members to make sure that if
the base has `@preconcurrency` declaration at some level. Otherwise,
the availability checker won't appropriately downgrade unavailable
`Sendable` conformances for `@preconcurrency` declarations.

Author: xedin

lib/Sema/TypeCheckAvailability.cpp

@@ -3593,17 +3593,9 @@ class ExprAvailabilityWalker : public BaseDiagnosticWalker {
 
     ExprStack.push_back(E);
 
-    if (auto *apply = dyn_cast<ApplyExpr>(E)) {
-      bool preconcurrency = false;
-      auto *fn = apply->getFn();
-      if (auto *selfApply = dyn_cast<SelfApplyExpr>(fn)) {
-        fn = selfApply->getFn();
-      }
-      auto declRef = fn->getReferencedDecl();
-      if (auto *decl = declRef.getDecl()) {
-        preconcurrency = decl->preconcurrency();
-      }
-      PreconcurrencyCalleeStack.push_back(preconcurrency);
+    if (isa<ApplyExpr>(E)) {
+      PreconcurrencyCalleeStack.push_back(
+          hasReferenceToPreconcurrencyDecl(E));
     }
 
     if (auto DR = dyn_cast<DeclRefExpr>(E)) {
@@ -3629,6 +3621,8 @@ class ExprAvailabilityWalker : public BaseDiagnosticWalker {
       if (S->hasDecl()) {
         diagnoseDeclRefAvailability(S->getDecl(), S->getSourceRange(), S);
         maybeDiagStorageAccess(S->getDecl().getDecl(), S->getSourceRange(), DC);
+        PreconcurrencyCalleeStack.push_back(
+            hasReferenceToPreconcurrencyDecl(S));
       }
     }
 
@@ -4007,6 +4001,41 @@ class ExprAvailabilityWalker : public BaseDiagnosticWalker {
                                  Flags))
       return;
   }
+
+  /// Check whether the given expression references any
+  /// @preconcurrency declarations.
+  /// Calls, subscripts, member references can have @preconcurrency
+  /// declarations at any point in their base chain.
+  bool hasReferenceToPreconcurrencyDecl(Expr *expr) {
+    if (auto declRef = expr->getReferencedDecl()) {
+      if (declRef.getDecl()->preconcurrency())
+        return true;
+    }
+
+    if (auto *selfApply = dyn_cast<SelfApplyExpr>(expr)) {
+      if (hasReferenceToPreconcurrencyDecl(selfApply->getFn()))
+        return true;
+
+      // Base could be a preconcurrency declaration i.e.
+      //
+      // @preconcurrency var x: [any Sendable]
+      // x.append(...)
+      //
+      // If thought `append` might not be `@preconcurrency`
+      // the "base" is.
+      return hasReferenceToPreconcurrencyDecl(selfApply->getBase());
+    }
+
+    if (auto *LE = dyn_cast<LookupExpr>(expr)) {
+      // If subscript itself is not @preconcurrency, it's base could be.
+      return hasReferenceToPreconcurrencyDecl(LE->getBase());
+    }
+
+    if (auto *apply = dyn_cast<ApplyExpr>(expr))
+      return hasReferenceToPreconcurrencyDecl(apply->getFn());
+
+    return false;
+  }
 };
 } // end anonymous namespace
 

test/Concurrency/predates_concurrency_swift6.swift

@@ -289,3 +289,22 @@ func testErasureDowngrade(ns: NotSendable, us: UnavailableSendable, c: C) {
     // expected-error@-1 {{conformance of 'UnavailableSendable' to 'Sendable' is unavailable}}
   }
 }
+
+// The member itself could be non-preconcurrency but the base could be.
+do {
+  @preconcurrency var d: [String: any Sendable] = [:]
+
+  let data: [String: Any] = [:]
+  d.merge(data, uniquingKeysWith: { _, rhs in rhs})
+  // expected-warning@-1 {{type 'Any' does not conform to the 'Sendable' protocol}}
+
+  struct Test {
+    @preconcurrency var info: [String: any Sendable] = [:]
+  }
+
+  func test(s: inout Test) {
+    s.info["hello"] = { }
+    // expected-warning@-1 {{type '() -> ()' does not conform to the 'Sendable' protocol}}
+    // expected-note@-2 {{a function type must be marked '@Sendable' to conform to 'Sendable'}}
+  }
+}